# Klassenerstellung für Matrix mit Rechenopperationen



## matt65 (6. Mai 2010)

Hallo,


ich nutze Eclipse zur Javaimplementation und dazugehörigen Editor:

ich habe folgendes Problem, und zwar bin ich dabei ein Javaprojekt zu erstellen, das sich um Matrizen handelt, beim anlegen der für die Matrizen notwendigen Arrays.
Für das Einlesen über Tastatur mit vorherriger Einbindung einer jar-Datei  sollte ich nun eine Klasse anlegen, doch scheitert dies.

Desweiteren sollte man anschließend mittels eingegebener Matrizen Rechenopperationen durchführen können, hab ich auch schon teilweise implementiert, doch auch hier schaffe ich es wieder nicht die  Unter-Klasse anzulegen, ohne das Auftreten von Fehlermeldungen und die zuvor eingegebene Matrix weiterzuverwenden.

Außerdem tritt jetzt kürzlich, Fehlermeldung über duplicate Variable a, b, c auf, keine Ahnung warum.
Wahrscheinlich habe ich irgendeine {} falsch gesetzt. (ab Zeile 43)
Nun zum Java-Text: (der ist villeicht etwas umständlich hatte aber anfangs recht gut funktioniert)



```
import algoj.*;  //Ein-Ausgabepaket über Tastatur

public class matratrix1 {

	/**
	 * @param args
	 */
	public static  void  main(String[] args) {

		// TODO Auto-generated method stub

		

		int a[][];// oder: z.B. int[][] matrixA =
		// {{5,4,1},{-3,1,3},{5,2,-3},{1,4,9}};
		int b[][];
		int c[][];
		int x[][];
		int m1 = 0;
		int m2 = 0;
		int mx = 0;

		int n1 = 0;
		int n2 = 0;
		int nx = 0;

		System.out.println("Matrizen m x n");
		System.out.println("=======================\n\n");// \n bedeutet new
		// line
	

	//class EinAus extends matratrix1 {   }

		{

				System.out.println("Eingabe der Werte für die Matrix:");

				for (int i = 0; i < m1; i++) {
					for (int j = 0; j < n1; j++) {
						System.out.println("a[" + i + "][" + j + "]:");
						a[i][j] = IOUtils.readInt();

					}

				}// Ausgabe der 1. Matrix A

				System.out.println("\n\nAusgabe der 1. Matrix:\n");
				for (int i = 0; i < a.length; i++) {
					for (int j = 0; j < a[0].length; j++) {
						System.out.print("\t" + a[i][j] + "\t");// t bedeutet
						// horizontaler Tabulator
					}
					System.out.println();

				}

				/*
				 * EINGABEN FUER DIE MATRIX -B-
				 */
				System.out.println("\n\nAnzahl der Zeilen der zweiten Matrix:");
				m2 = IOUtils.readInt();
				System.out.println("Anzahl der Spalten der zweiten Matrix:");
				n2 = IOUtils.readInt();

				b = new int[m1][n1];
				{

					System.out.println("Eingabe der Werte für die Matrix:");
					for (int i = 0; i < m2; i++) {
						for (int j = 0; j < n2; j++) {
							System.out.println("b[" + i + "][" + j + "]:");
							b[i][j] = IOUtils.readInt();

						}
					}
					// Ausgabe der 2. Matrix B
					System.out.println("\n\nAusgabe der 2. Matrix:\n");
					for (int i = 0; i < b.length; i++) {
						for (int j = 0; j < b[0].length; j++) {
							System.out.print("\t" + b[i][j] + "\t ");
						}
						System.out.println();
					}

					/*
					 * EINGABEN FUER DIE MATRIX -X-
					 */
					System.out
							.println("\n\nAnzahl der Zeilen der x-ten Matrix:");
					mx = IOUtils.readInt();
					System.out.println("Anzahl der Spalten der x-ten Matrix:");
					nx = IOUtils.readInt();

					x = new int[m1][n1];

					System.out.println("Eingabe der Werte für die Matrix:");
					for (int i = 0; i < mx; i++) {
						for (int j = 0; j < nx; j++) {
							System.out.println("x[" + i + "][" + j + "]:");
							x[i][j] = IOUtils.readInt();

						}
					}
					// Ausgabe der x. Matrix X
					System.out.println("\n\nAusgabe der x. Matrix:\n");
					for (int i = 0; i < x.length; i++) {
						for (int j = 0; j < x[0].length; j++) {
							System.out.print("\t" + x[i][j] + "\t ");
						}
						System.out.println();

					}
				
		//class Matrix extends EinAus {    }
					
					
				// Berechnung der Summe zweier Matrizen
				System.out.println("\n\nAusgabe des Ergebnisses"
						+ " der Addition zweier Matrizen:");

				}
		}
		
	}

			public int[][] addiereMatrizen(int a[][], int b[][], int c[][]) 
			{
			int[][] c = new int[a.length][a[0].length];
			for (int i = 0; i < c.length; i++) {    
				System.out.println("\n\nAusgabe des Ergebnisses der Addition zweier Matrizen:");
				{
				for (int j = 0; j < c[0].length; j++) {
				System.out.print("\t" + c[i][j] + " ");
						}
					}
					System.out.println();}
				}
			
	
	}
```

Der Fehler setzt sich auch in der Addition fort, falls jemand den Fehler endeckt, wäre echt super


Vielleicht könnte mir jemand hierbei behilflich sein, damit ich die Anfängerfehler beheben kann.;(

Schönen Dank im voraus.


----------



## kulri (6. Mai 2010)

poste doch bitte auch die Fehlermeldungen/Exceptions


----------



## matt65 (6. Mai 2010)

So hier nochmal der Java-Text + eingefügten Klassen, irgendwas mach ich da falsch mit anschließender Fehlerbeschreibung:




```
import algoj.*;  //Ein-Ausgabepaket über Tastatur
 

public class Matr {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub{
 
    
        
 
        int a[][];// oder: z.B. int[][] matrixA =
        // {{5,4,1},{-3,1,3},{5,2,-3},{1,4,9}};
        int b[][];
        int c[][];
        int x[][];
        int m1 = 0;
        int m2 = 0;
        int mx = 0;
 
        int n1 = 0;
        int n2 = 0;
        int nx = 0;
 
        System.out.println("Matrizen m x n");
        System.out.println("=======================\n\n");// \n bedeutet new
        // line
    
 
    //class EinAus extends matratrix1 {   }
 
        {  class EinAus extends Matr {
 
                System.out.println("Eingabe der Werte für die Matrix:");
 
                for (int i = 0; i < m1; i++) {
                    for (int j = 0; j < n1; j++) {
                        System.out.println("a[" + i + "][" + j + "]:");
                        a[i][j] = IOUtils.readInt();
 
                    }
 
                }// Ausgabe der 1. Matrix A
 
                System.out.println("\n\nAusgabe der 1. Matrix:\n");
                for (int i = 0; i < a.length; i++) {
                    for (int j = 0; j < a[0].length; j++) {
                        System.out.print("\t" + a[i][j] + "\t");// t bedeutet
                        // horizontaler Tabulator
                    }
                    System.out.println();
 
                }
 
                /*
                 * EINGABEN FUER DIE MATRIX -B-
                 */
                System.out.println("\n\nAnzahl der Zeilen der zweiten Matrix:");
                m2 = IOUtils.readInt();
                System.out.println("Anzahl der Spalten der zweiten Matrix:");
                n2 = IOUtils.readInt();
 
                b = new int[m1][n1];
                {
 
                    System.out.println("Eingabe der Werte für die Matrix:");
                    for (int i = 0; i < m2; i++) {
                        for (int j = 0; j < n2; j++) {
                            System.out.println("b[" + i + "][" + j + "]:");
                            b[i][j] = IOUtils.readInt();
 
                        }
                    }
                    // Ausgabe der 2. Matrix B
                    System.out.println("\n\nAusgabe der 2. Matrix:\n");
                    for (int i = 0; i < b.length; i++) {
                        for (int j = 0; j < b[0].length; j++) {
                            System.out.print("\t" + b[i][j] + "\t ");
                        }
                        System.out.println();
                    }
 
                    /*
                     * EINGABEN FUER DIE MATRIX -X-
                     */
                    System.out
                            .println("\n\nAnzahl der Zeilen der x-ten Matrix:");
                    mx = IOUtils.readInt();
                    System.out.println("Anzahl der Spalten der x-ten Matrix:");
                    nx = IOUtils.readInt();
 
                    x = new int[m1][n1];
 
                    System.out.println("Eingabe der Werte für die Matrix:");
                    for (int i = 0; i < mx; i++) {
                        for (int j = 0; j < nx; j++) {
                            System.out.println("x[" + i + "][" + j + "]:");
                            x[i][j] = IOUtils.readInt();
 
                        }
                    }
                    // Ausgabe der x. Matrix X
                    System.out.println("\n\nAusgabe der x. Matrix:\n");
                    for (int i = 0; i < x.length; i++) {
                        for (int j = 0; j < x[0].length; j++) {
                            System.out.print("\t" + x[i][j] + "\t ");
                        }
                        System.out.println();
 
                    }
                }
        }
                
        //class Matrix extends EinAus {    }
                    
          class Matrix extends EinAus {
        	  
          
                // Berechnung der Summe zweier Matrizen
                System.out.println("\n\nAusgabe des Ergebnisses"
                        + " der Addition zweier Matrizen:");
 
             
            public int[][] addiereMatrizen(int a[][], int b[][], int c[][]) 
            {
            int[][] c = new int[a.length][a[0].length];
            for (int i = 0; i < c.length; i++) {    
                System.out.println("\n\nAusgabe des Ergebnisses der Addition zweier Matrizen:");
                {
                for (int j = 0; j < c[0].length; j++) {
                System.out.print("\t" + c[i][j] + " ");
                        }
                    }
                    System.out.println();}
                }
            
          
          
                

	
        }
```


```
Exception in thread "main" java.lang.Error: Unresolved compilation problems: 
	Syntax error on token(s), misplaced construct(s)
	Syntax error on token(s), misplaced construct(s)
	EinAus cannot be resolved to a type
	Syntax error on token "(", ; expected
	Syntax error on token ",", ; expected
	Syntax error on token ",", ; expected
	Syntax error on token ")", ; expected
	Duplicate local variable c

	at Matr.main(Matr.java:35)
```


----------



## kulri (6. Mai 2010)

die öffnende geschweift Klammer in Zeile 36 kommt mir spanisch vor  hier solltest du eher die schließende Klammer deiner main-methode sowie die schließende Klammer deiner Matr-Klasse setzen....
Grundsätzlich solltest du nicht mehrere Klassen in einer Datei definieren, schon aufgrund der Übersichtlichkeit.... aber wenn du drauf bestehst, dann sollte die Struktur deiner Java-Datei etwa so aussehen:


```
class A {

    private static void main(...){

    }
}

class B {

    public void anyMethod(){

    }

}
```


----------



## SlaterB (6. Mai 2010)

nicht tausende Befehle durcheinander schreiben und dann nicht mehr durchsehen, was wo hingehört,
fange mit einer sauberen Grundstruktur an, dein Code sieht in etwa aus wie

```
class Matr
{

    public static void main(String[] args)
    {
        {
            class EinAus
                extends Matr
            {


            }
            class Matrix
                extends EinAus
            {


            }
        }
    }
}
```
?
ein Klammernpaar davon ist schon überflüssig,
und bedenke dass man keinen normalen Code direkt in eine Klasse schreiben kann, immer nur in Methoden,

was hast du eigentlich vor?
jedenfalls mit einfachen leeren kompilierenden Klassen anfangen und nach und nach Methoden + deren Inhalt einfpgen


----------



## nrg (6. Mai 2010)

Sind halt einige kompilierfehler. du hast 2x die variable c, kommasetzung, klammerung... aber ich hab jetzt keine lust die die java syntax zu erklären. die solltest du selbst lernen.

mein vorschlag:

erstell doch mal eine Klasse Matrix. Einen Konstruktor Matrix(int m, int n) (dort dann auch das array initialisieren anhand von m und n) und eine Methode initMatrix(). Dann übenimmst du dort den Code und sparst dir mindestens 1/3 schreibarbeit. Dann das weng ein Blabla in der main rumpacken und deine Matrizen initialisieren. Danach reden wir über addition...

Falls du OOP noch nicht ausführlich durchgenommen hast, nimm ich das zurück .


----------



## matt65 (6. Mai 2010)

Hi,

schonmal Danke

ich werde jetzt mal versuchen die Klassen in jeweils einem eigenem Dokument erstmal zu erstellen, um sie dann hinterher in der Oberklasse integrieren zu können.
#


----------



## matt65 (6. Mai 2010)

So habe noch eine Frage: 

Wie kann ich nach Erstellung der einzelnen Klassen dann in dem Hauptprojekt 
z.b. in der einen Klasse erstellten Matrix auf genau diese nun zugreifen?

Ne also, des mit den Methoden zu erstellen  ist mir auch noch nicht ganz klar.
Könnte jemand nochmal die Einbindung der Klassen in das Hauptprojekt schildern.

Habe jetzt also class EinAus (Matrix einlesen und ausgeben per Tastatur),
class Matrix (Rechenopperationen sollen dort mittels Methoden durchgeführt werden)
einzeln vorliegen;

Wie läuft jetzt die Einbindung dann ab (in das Hauptprogramm)?

Vielen Dank für die Antworten


----------



## SlaterB (6. Mai 2010)

statische Operationen an der Klasse aufrufen wie 
Math.sin()

ansonsten Objekte erstellen
List l = new ArrayList();
l.add();


----------



## nrg (6. Mai 2010)

```
public class Matrix {
	
	private int[][] matrix;
	private int n;
	private int m;
	
	public Matrix( int n, int m ) {
		matrix = new int[n][m];
	}
	
	public int[][] getMatrix() {
		return matrix;
	}
	
	public void initMatrix() {
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                System.out.print("a[" + i + "][" + j + "]: ");
                matrix[i][j] = IOUtils.readInt();
            }
        }
	}
	
	public void printMatrix() {
	    for (int i = 0; i < m; i++) {
	        for (int j = 0; j < n; j++) {
	            System.out.print("\t" + matrix[i][j] + "\t");
	        }
	        System.out.println();
	    }
	}
}
```


```
public class Test  {

	public static void main(String[] args) throws IOException {
		System.out.println("\n\nAnzahl der Zeilen der ersten Matrix:");
		int m = IOUtils.readInt();
		System.out.println("Anzahl der Spalten der ersten Matrix:");
		int n = IOUtils.readInt();
		Matrix matrixA = new Matrix( m, n );
		matrixA.initMatrix();
		matrixA.printMatrix();

		System.out.println("\n\nAnzahl der Zeilen der zweiten Matrix:");
		m = IOUtils.readInt();
		System.out.println("Anzahl der Spalten der zweiten Matrix:");
		n = IOUtils.readInt();
		Matrix matrixB = new Matrix( m, n );
		matrixB.initMatrix();
		matrixB.printMatrix();

		// ....
	}
}
```

so in etwa (ungetestet). m und n könntest dir eigentlich als Instanzvariable sparen aber so musste zumindest net mit array.length bzw array[0].length rumhantieren

edit: sieht jetzt aus wie eine Komplettlösung aber ich hab jetzt ausser Copy&Paste nichts gemacht. Kuck dir das mal an und wennste das nachvollziehen kannst probier eine Methode addMatrix zu implementieren. Der Aufruf davon könnte zb so aussehen:

matrixA.addMatrix(matrixB.getMatrix());
matrixA.printMatrix();


----------



## matt65 (6. Mai 2010)

Hi, 
cool das du dir die Mühe gemacht hast!


hab jetzt mal probiert die Implementierung etwas anzupassen, komme dann auf folgendes Ergebnis:


Klasse test:


```
import java.io.IOException;

import algoj.*;

public class test {

	/**
	 * @param args
	 */
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub

				System.out.println("Matrizen");
				System.out.println("=======================\n");
				 
		        System.out.println("\nAnzahl der Zeilen der Matrix:");
		        int m = IOUtils.readInt();
		        System.out.println("Anzahl der Spalten der Matrix:");
		        int n = IOUtils.readInt();
		        Matrix matrixA = new Matrix( m, n );
		        matrixA.initMatrix();
		        matrixA.printMatrix();
		 
		        System.out.println("\n\nAnzahl der Zeilen der Matrix:");
		        m = IOUtils.readInt();
		        System.out.println("Anzahl der Spalten der Matrix:");
		        n = IOUtils.readInt();
		        Matrix matrixB = new Matrix( m, n );
		        matrixB.initMatrix();
		        matrixB.printMatrix();
		 
		        
		        System.out.println("\n\nAnzahl der Zeilen der Matrix:");
		        m = IOUtils.readInt();
		        System.out.println("Anzahl der Spalten der Matrix:");
		        n = IOUtils.readInt();
		        Matrix matrixC = new Matrix( m, n );
		        matrixC.initMatrix();
		        matrixC.printMatrix();
		        
		        
		        System.out.println("\n\nAnzahl der Zeilen der Matrix:");
		        m = IOUtils.readInt();
		        System.out.println("Anzahl der Spalten der Matrix:");
		        n = IOUtils.readInt();
		        Matrix matrixD = new Matrix( m, n );
		        matrixD.initMatrix();
		        matrixD.printMatrix();
				
		       
		    }
		
	}
```

Kann das sein, dass obiger Text nur für quadratische, d.h. 2x2, 3x3 Matrizen geht, bzw. wie muss ich ihn verändern, dass es auch mit anderen, nicht quadrat. Matrizen geht.

Außerdem Klasse Matrix:


```
import algoj.*;

public class Matrix {

	public int[][] matrix;
	public int n;
	public int m;

	public Matrix(int n, int m) {
		matrix = new int[n][m];

		System.out.println("Es folgt die Eingabe der Werte:");
		for (int i = 0; i < m; i++) {
			for (int j = 0; j < n; j++) {
				System.out.println("a[" + i + "][" + j + "]:");
				matrix[i][j] = IOUtils.readInt();
			}
		}
	}

	public int[][] getMatrix() {
		return matrix;
	}

	public void initMatrix() {
		
		for (int i = 0; i < m; i++) {
			for (int j = 0; j < n; j++) {
				System.out.print("a[" + i + "][" + j + "]: ");
				matrix[i][j] = IOUtils.readInt();
			}
		}
	}

	public void printMatrix() {

		for (int i = 0; i < m; i++) {
			for (int j = 0; j < n; j++) {
				System.out.print("\t" + matrix[i][j] + "\t");
			}
			System.out.println();
		}

		System.out.println("\n\nAusgabe der Matrix:\n");
		for (int i = 0; i < matrix.length; i++) {
			for (int j = 0; j < matrix[0].length; j++) {
				System.out.print("\t" + matrix[i][j] + "\t");// t bedeutet
				// horizontaler Tabulator
			}
			System.out.println();

		}
	}
}
```

Sehe ich das richtig, dass wenn ich das Programm ablaufen lasse, von der Klasse test aus auf die Klasse Matrix zugegriffen und daraus die Matrizen erstellt werden?


----------



## nrg (6. Mai 2010)

ups. hab vergessen im konstuktor auch m und n zu initialisieren 

aber du hast dir ja gut beholfen. entweder du änderst den konstruktor:

```
public Matrix(int n, int m) {
        matrix = new int[n][m];
        this.m = m;
        this.n = n;
        .....
```
und dann eben alle Schleifenköpfe so (war ein kleiner dreher drin):

```
for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
```



oder du lässt m und n komplett weg und machst alle Schleifenköpfe so:

```
for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[0].length; j++) {
```



wenn du das jetzt anpasst, wirste schnell merken, dass du jetzt paar sachen doppelt hast. (init - einmal im konstuktor und einmal mit der mehtode und die ausgabe 2x in der methode). Dann musste das halt nochmal bissle anpassen 

edit: und jetzt fehlt noch die Methode addMatrix(int[][] matrix) in der Klasse Matrix. Das machste aber selber. Dabei kannste auch gleich die Überladung üben: addMatrix(Matrix matrix)


----------



## matt65 (6. Mai 2010)

Also gut, die Eingabe der Matrizen habe ich soweit hinbekommen, nach einigen Versuchen;
aber bei der Addition hakt es noch immer:

Ich habe jetzt versucht die Methode addMatrix zu erstellen


```
public void addMatrix(int[][] matrix){
		for (int i=0; i<matrix.length; i++) {
		    for (int j=0; j<matrix[i].length; j++) {
			matrix[i][j] = matrix[i][j] + matrix[i][j];
		    
			    }
		}
		matrix = new int[n][m];
```

Doch führt er diese nach Eingabe in der test Klasse nicht aus.


```
System.out.println("Ergebnis aus der Addition der Matrizen A + B:");
		        getMatrix(matrixA.initMatrix (m,n));
		        getMatrix(matrixB.initMatrix (m,n));
		        addMatrix(matrixA (m,n) + matrixB (m,n));
		        addMatrix = new matrixE (m,n);
```

Zuerst habe ich versucht mit getMatrix die eingegebenen Matrizen A, B für das Addieren zu holen, klappt aber nicht. Ergebnis wollte ich als MatrixE defienieren und anschließend ausgeben.
Was mach ich da falsch?


----------



## nrg (6. Mai 2010)

die methode addMatrix passt schon fast. nur verwende das this schlüsselwort. namensdeklaration ist immer auf unterster ebene. dh wenn du einen paramter und eine instanzvariable matrix hast ist in der methode matrix der paramater und this.matrix die instanzvariable.
matrix = new int[n][m]; am Ende der Methode kann ich nicht nachvollziehen. das kannste streichen .

und dann mach mal folgendes:
matrixA.addMatrix(matrixB.getMatrix());
matrixA.printMatrix();

aber nach dem Versuch würde ich dir erstmal ein Tutorial zur OOP empfehlen.
Ich empfehle immer wieder dieses Tutorial:
Java Tutorial interaktiv - Programmieren lernen mit Java
ist schon ein bissle älter aber erklärt es meiner Meinung nach wunderbar. "Die Insel", die so gern genannt wird, halte ich für den Anfang sehr ungeeignet (eher später zum Nachschlagen interessant).


----------



## matt65 (7. Mai 2010)

Ja gut, ich weiß schon, dass ich noch einige Defizite habe, hab mich schon mal ein wenig durchgeklickt beim Tutorial.

Trotzdem hänge ich immer noch fest:

Habe jetzt die Klasse AddMatrix wie folgt erstellt (funktioniert auch soweit), bin mir aber nicht sicher, ob ich das mit dem this.matrix richtig umgesetzt habe.
Das Problem bei addMatrix ist nur noch das das Schlüsselwort "that" nicht erkannt wird, was muss ich ändern?


```
public int m() {
		return this.m;
	}

	public int n() {
		return this.n;
	}

	// Addition der Matrizen
	public void addMatrix(int[][] matrix) {
		if((this.m() != that.m() && this.n() != that.n())){
		System.out.println("Bedingung Zeilen- und Spaltenanzahl stimmen nicht überein"); 
		}

		for (int i = 0; i < matrix.length; i++) {
			for (int j = 0; j < matrix[i].length; j++) {
				this.matrix[i][j] = this.matrix[i][j] + matrix[i][j];

			}
		}

	}
```

Könnte sich jemand darüber hinaus nochmal die Subtraktion anschauen, da kommen bei mir nämlich falsche Werte raus:


```
public void subMatrix(int[][] matrix) {

		for (int i = 0; i < matrix.length; i++) {
			for (int j = 0; j < matrix[i].length; j++) {
				this.matrix[i][j] = matrix[i][j] - matrix[i][j];
			}
		}
	}
```

Bin für jede Antwort dankbar.


----------



## Landei (7. Mai 2010)

LOL!

that ist kein Schlüsselwort!

Man macht es, um (rein sprachlich) deutlich zu machen, dass das eigene Objekt (this) mit einem anderen (that) irgendwie verknüpft wird, aber dazu muss man das Argument schon selber so nennen.


```
class Foo {
   private int i;
   
   public Foo(int i) {
      this.i = i;
   } 

   public Foo add(Foo that) {
      return new Foo(this.i + that.i);
   } 
}
```

In deinem zweiten Problem verwechselst du die Instanzvariable matrix mit dem Funktionsargument matrix. Umbenennen und schon sollte es gehen:


```
public void subMatrix(Matrix that) {
        //hier sollte man noch überprüfen, ob that.matrix die gleiche Größe hat
        for (int i = 0; i < this.matrix.length; i++) {
            for (int j = 0; j < this.matrix[i].length; j++) {
                this.matrix[i][j] = this.matrix[i][j] - that.matrix[i][j];
                //oder kürzer:
                //this.matrix[i][j] -= that.matrix[i][j];
            }
        }
    }
```

Wenn du wirkich ein Array statt einer Matrix abziehen willst (was aber unschön wäre), müsstest du schreiben:

```
public void subMatrix(int[][] m) {
        //hier sollte man noch überprüfen, ob that.matrix die gleiche Größe hat
        for (int i = 0; i < this.matrix.length; i++) {
            for (int j = 0; j < this.matrix[i].length; j++) {
                this.matrix[i][j] = this.matrix[i][j] - m[i][j];
                //oder kürzer:
                //this.matrix[i][j] -= m[i][j];
            }
        }
    }
```


----------



## matt65 (7. Mai 2010)

Achso, bekomme es mit dem that dennoch nicht hin;

müsste aber doch so auch gehen, oder?


```
public void subMatrix(int[][] matrix ) {

		for (int i = 0; i < this.matrix.length; i++) {
			for (int j = 0; j < this.matrix[i].length; j++) {
				this.matrix[i][j] = this.matrix[i][j] - matrix[i][j];
			}
		}
	}
```

Des mit dem that klappt nämlich nicht.

Als Ausgabe in der test Klasse habe ich:


```
//Ausgabe Ergebnis Subtraktion
		        System.out.println("\nErgebnis aus der Subtraktion der Matrizen A - B:");
		        matrixA.subMatrix(matrixB.getMatrix());
		        matrixA.printMatrix();
```

Ich bekomme immer die matrixA ausgegeben.


----------



## nrg (7. Mai 2010)

das mit dem "that" vergiss mal ganz schnell wieder.

@Landei: machs doch nicht noch komplizierter als es eh schon ist . wenn du den thread anschaust, merkste doch, dass sowas nur verwirren kann .

>müsste aber doch so auch gehen, oder?

genau so sollte es aussehen.

jetzt könntest du vorher aber noch abprüfen, ob die matrizen gleich sind. Somit beachtest du nicht nur die Regeln für Matrizen  bei sub/addition sondern verhinderst du eine ArrayIndexOutOfBoundsException zur Laufzeit.


----------



## matt65 (7. Mai 2010)

Nochmal zur Überprüfung der Zeilen und Spaltenanzahl der Matrizen auf Gleichheit:

Wie soll ich das am besten anstellen: So ähnlich müsste das doch ausschauen in der Klasse Matrix


```
// Addition der Matrizen
	public void addMatrix(int[][] matrix) {
		if (this.matrix.length != matrix.length
				&& this.matrix[i].length != matrix[i].length) {
			System.out.println("Bedingung über Gleichheit der  Zeilen- und Spaltenanzahl  nicht erfüllt");
			

			for (int i = 0; i < matrix.length; i++) {
				for (int j = 0; j < matrix[i].length; j++) {
					this.matrix[i][j] = this.matrix[i][j] + matrix[i][j];
				}
			}
		}
	}
```

Jetzt gibts auch den Fehler:

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 2
	at Matrix.addMatrix(Matrix.java:68)
	at test.main(test.java:52)



Außerdem, wie schaut es jetzt mit der Subtraktion aus, irgenwas stimmt doch dort auch nicht;
es folgt immer eine falsche Ausgabe, und es wird keine Rechenopperation "-" ausgeführt, woran kann das liegen?
Lediglich die matrixA wird ausgegeben

Das ist der Text class Matrix

```
public void subMatrix(int[][] matrix) {

		for (int i = 0; i < this.matrix.length; i++) {
			for (int j = 0; j < this.matrix[i].length; j++) {
				this.matrix[i][j] = this.matrix[i][j] - matrix[i][j];
			}
		}
	}
```

Und das die Ausführung in der Test-Klasse:


```
//Ausgabe Ergebnis Subtraktion
		        System.out.println("\nErgebnis aus der Subtraktion der Matrizen A - B:");
		        matrixA.subMatrix(matrixB.getMatrix());
		        matrixA.printMatrix(); 
		        
		    }
```


----------



## Antoras (7. Mai 2010)

Zu addMatrix:
Du überprüfst ob die Matrizen nicht von der Größe her nicht übereinstimmen und wenn ja, dann willst du sie miteinander addieren -> Fehler.
Außerdem stimmt deine Abfrage nicht. Du willst ja, dass bei Ungleichheit von Spalten UND Reihen eine Fehlermeldung ausgegeben wird und nicht nur wenn beides ungleich ist. Also benötigst du eine ODER-Verknüpfung.

Zu subMatrix:
Sicher, dass deine zu subtrahierende Matrix mit Werten gefüllt ist, die ungleich 0 sind?


----------



## matt65 (7. Mai 2010)

okay das mit der Überprüfung mit den Zeilen und Spalten muss ich nochmal anschauen und eine ODER verknüpfung also wie nachfolgend zu sehen, überarbeiten.
Sollte dann so aussehen: nur Fehler: i cannot be resolved 


```
// Addition der Matrizen
	public void addMatrix(int[][] matrix) {
		if (this.matrix.length != matrix.length
				|| this.matrix[i].length != matrix[i].length) {
			System.out
					.println("Bedingung über Gleichheit der  Zeilen- und Spaltenanzahl  nicht erfüllt");

			for (int i = 0; i < matrix.length; i++) {
				for (int j = 0; j < matrix[i].length; j++) {
					if (this.matrix.length != matrix.length
							&& this.matrix[i].length != matrix[i].length) {
						System.out.println("Bedingung über Gleichheit der  Zeilen- und Spaltenanzahl  nicht erfüllt");
						this.matrix[i][j] = this.matrix[i][j] + matrix[i][j];
					}
				}
			}
		}
	}
```

Zu der Subraktion, kann ich nur sagen, dass ich die Matrix mit Werten ungleich 0 befüllt habe, deshalb kann ich mir das auch nicht ganz erklären, warum er die matrixA ohne Veränderung wieder ausgibt.


----------



## nrg (7. Mai 2010)

[0].length

i haste ja nur in den schleifen deklariert. dann nurnoch einen return; um die methode dann auch abzubrechen!

if ( blabla ) {
System.out.println( "bla" );
return;
}
for ......

edit: die abfrage in der schleife kansnte dir dann sparen. hast doch eh immer n mal m.
zur subtraktion müsste man mal code sehen


----------



## matt65 (7. Mai 2010)

Schau mir gleich mal deinen Vorschlag an, diesen umzusetzten;
erstmal hier nochmal die Subtraktion:



```
public void subMatrix(int[][] matrix) {

		for (int i = 0; i < this.matrix.length; i++) {
			for (int j = 0; j < this.matrix[i].length; j++) {
				this.matrix[i][j] = this.matrix[i][j] - matrix[i][j];
			}
		}
	}
```

und hier Ausgabe in der test class


```
//Ausgabe Ergebnis Subtraktion
		        System.out.println("\nErgebnis aus der Subtraktion der Matrizen A - B:");
		        matrixA.subMatrix(matrixB.getMatrix());
		        matrixA.printMatrix(); 
		        
		    }
```


----------



## nrg (7. Mai 2010)

ja, sollte aber passen. hät mich jetzt auch gewundert, wenn du beim ersetzen vom + mit - einen fehler gemacht hättest .
dann ist irgendwo anders ein fehler.
kannst ja nochmal alles posten


----------



## matt65 (7. Mai 2010)

So hier ist der komplette Code:
Klasse Matrix:

```
public class Matrix {

	public int[][] matrix;
	public int n;
	public int m;

	public Matrix(int n, int m) {
		matrix = new int[n][m];
		this.m = m;
		this.n = n;

		System.out.println("Es folgt die Eingabe der Werte:");
		for (int i = 0; i < matrix.length; i++) {
			for (int j = 0; j < matrix[0].length; j++) {
				System.out.println("a[" + i + "][" + j + "]:");
				matrix[i][j] = IOUtils.readInt();
			}
		}
	}

	public int[][] getMatrix() {
		return matrix;
	}

	public void initMatrix() {

		for (int i = 0; i < matrix.length; i++) {
			for (int j = 0; j < matrix[0].length; j++)
				;

		}
	}

	public void printMatrix() {

		System.out.println("\n\nAusgabe der Matrix:\n");
		for (int i = 0; i < matrix.length; i++) {
			for (int j = 0; j < matrix[0].length; j++) {
				System.out.print("\t" + matrix[i][j] + "\t");// t bedeutet
				// horizontaler Tabulator
			}
			System.out.println();

		}
	}

	public int m() {
		return this.m;
	}

	public int n() {
		return this.n;
	}

	// Addition der Matrizen
	public void addMatrix(int[][] matrix) {
		if (this.matrix.length != matrix.length
				|| this.matrix[0].length != matrix[0].length) {
			System.out
					.println("Bedingung über Gleichheit der  Zeilen- und Spaltenanzahl  nicht erfüllt");
			return;
		}

		for (int i = 0; i < matrix.length; i++) {
		for (int j = 0; j < matrix[i].length; j++) {
			this.matrix[i][j] = this.matrix[i][j] + matrix[i][j];
				}
			}
		}
	

	public void subMatrix(int[][] matrix) {
		if (this.matrix.length != matrix.length
				|| this.matrix[0].length != matrix[0].length) {
			System.out
					.println("Bedingung über Gleichheit der  Zeilen- und Spaltenanzahl  nicht erfüllt!");
			return;
		}
		for (int i = 0; i < this.matrix.length; i++) {
			for (int j = 0; j < this.matrix[i].length; j++) {
				this.matrix[i][j] = this.matrix[i][j] - matrix[i][j];
			}
		}
	}
}
```

und hier die test:


```
import java.io.IOException;

import algoj.*;

public class test {

	/**
	 * @param args
	 */
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub

				System.out.println("Matrizen");
				System.out.println("=======================\n");
				 
		        System.out.println("\nAnzahl der Zeilen der Matrix:");
		        int m = IOUtils.readInt();
		        System.out.println("Anzahl der Spalten der Matrix:");
		        int n = IOUtils.readInt();
		        Matrix matrixA = new Matrix( m, n );
		        matrixA.initMatrix();
		        matrixA.printMatrix();
		 
		        System.out.println("\n\nAnzahl der Zeilen der Matrix:");
		        m = IOUtils.readInt();
		        System.out.println("Anzahl der Spalten der Matrix:");
		        n = IOUtils.readInt();
		        Matrix matrixB = new Matrix( m, n );
		        matrixB.initMatrix();
		        matrixB.printMatrix();
		 
		        
		        System.out.println("\n\nAnzahl der Zeilen der Matrix:");
		        m = IOUtils.readInt();
		        System.out.println("Anzahl der Spalten der Matrix:");
		        n = IOUtils.readInt();
		        Matrix matrixC = new Matrix( m, n );
		        matrixC.initMatrix();
		        matrixC.printMatrix();
		        
		        
		        System.out.println("\n\nAnzahl der Zeilen der Matrix:");
		        m = IOUtils.readInt();
		        System.out.println("Anzahl der Spalten der Matrix:");
		        n = IOUtils.readInt();
		        Matrix matrixD = new Matrix( m, n );
		        matrixD.initMatrix();
		        matrixD.printMatrix();
				
		       //Ausgabe Ergebnis Addition
		        System.out.println("Ergebnis aus der Addition der Matrizen A + B:");
		        matrixA.addMatrix(matrixB.getMatrix());
		        matrixA.printMatrix();
		        
		        //Ausgabe Ergebnis Subtraktion
		        System.out.println("\nErgebnis aus der Subtraktion der Matrizen A - B:");
		        matrixA.subMatrix(matrixB.getMatrix());
		        matrixA.printMatrix(); 
		        
		    }
		
	}
```


----------



## Antoras (7. Mai 2010)

Also, ich kann da jetzt keinen Fehler erkennen. Ich kann mir nur vorstellen, dass du auf die falschen Werte achtest. Du addierst als erstes B zu A und dann subtrahierst du B wieder von A. Am Schluss hast du also wieder A. Wenn du jetzt nicht auf das Ergebnis dar Addition, sondern auf die Initialisierungswerte achtest, dann ist klar warum da in deinen Augen nichts subtrahiert wird.


----------



## nrg (7. Mai 2010)

wird vermutlich so sein, wie es der vorposter schon gesagt hat.

paar schönheitsfehler noch:

public void m = public void getM
gleiche für n
test = Test


----------



## matt65 (7. Mai 2010)

Stimmt, ist ja eigentlich logisch;

meine neue Matrix A = ursprünglich A + B

dann subtrahiere ich wieder von neuer M. A - B
und es kommt wieder A raus.

Was müsste ich jetzt konkret ändern, damit ich ich in der Ausführung, die nacheinander die Rechenopperationen ablaufen lassen soll, wieder auf die ursprüngliche, von mir eingegebene Matrix zugreifen kann.

z.b. matrixA.getMatrix();
funktioniert dann aber auch nicht mehr, da die neue Matrix A ja schon andere Werte nach der Addition zugewiesen bekommen hat.


----------



## nrg (7. Mai 2010)

langsam frag ich mich eher nach dem sinn von dem tool . willst du einen richtigen Rechner bauen? Wenn ja, solltest du ganz einfach ein shellmenu basteln worin man zwischen mehrere optonen entscheiden kann. wenn ich mal zurückschaue wie weit wir bis jetzt gekommen sind wär der thread dann ca nach 200 beinträgen erledigt .


----------



## matt65 (7. Mai 2010)

Nein, also einen Rechner will ich nicht bauen;
ich wollte jetzt eigentlich nur noch ein paar Rechenopperationen, wie Addition, Subtraktion, Multiplikation integrieren.


----------



## nrg (7. Mai 2010)

ok. addition und subtraktion funktioniert. dann mach mal die multiplikation 

edit: achja. kapsel deine attribute in der Klasse Matrix noch, sonst machen die getter wenig sinn


----------



## matt65 (7. Mai 2010)

ja eine Kapselung kann ich machen, allerdings hab ich davon sogut wie keine Ahnung;
meinst du damit private, public class, da komme ich aber nicht ganz zurecht.
Die Folge ist, dass von der anderen Klasse dann nicht mehr zugegriffen werden kann, nachdem ich eine Klasse als private deklariert habe.

Könntest du mir vielleicht dazu für meine entsprechenden Klassen ein Beispiel geben, damit ich die Kapselung durchführen kann.

Behebt das wohl das Problem mit der Methode "Holen der ursprünglichen, eingegebenen Matrix", wie oben beschrieben, sodass man bei der Subtraktion auch was sieht, oder gibt es was anderes, damit ich die ursprüngliche Matrix holen kann, vielleicht break Anweisung zwischen Addition - Subtraktion - Multiplikation schalten, o.Ä.

Das mit der Multiplikation gestaltet sich ebenfalls für mich als schwierig, habe mal was erzeugt, was nicht ganz funktioniert.


```
public void mulMatrix(int[][] matrix) {
		if (this.matrix.length != matrix.length
				|| this.matrix[0].length != matrix[0].length) {
			System.out
					.println("Bedingung über Gleichheit der  Zeilen- und Spaltenanzahl  nicht erfüllt!");
			return;
		}
				
		for (int i = 0; i < this.matrix.length; i++) {
		for (int j = 0; j < matrix[0].length; j++) {
		for (int k = 0; k < this.matrix[0].length; k++) {
			this.matrix[i][j] += matrix[i][k] * matrix[k][j];

				}
			}
		}
	}
```


----------



## nrg (7. Mai 2010)

multiplikation gestaltet sich auch ein wenig komplizierter. solltest erstmal allgemein verstehen, wie man matrizen multipliziert . hab grad leider keine zeit um mit code zu dienen. google dich einfach mal durch

zur kapselung. solltest auch mal meine links die ich dir schreibe anschauen. das tutorial ist wirklich sehr gut:
Kapitel 33 — Kapselung (Verbergen von Daten)

einfach durchlesen. kostet dich 10 minuten und ich bräuchte ca 30 um dir das so ausführlich wie in dem tutorial hier im forum zu erklären...


----------



## JohannisderKaeufer (7. Mai 2010)

Ich bin mal ganz ketzerisch!

matrixA[a]**matrixB[c] = matrix[a][c]


Somit wird aus deiner Überprüfung



		Java:In die Zwischenablage kopieren


if(this.matrix[0].length == matrix.length)

Das return; ist häßlich!

Versuche es mit 


		Java:In die Zwischenablage kopieren


if(sieheOben()){
  System.out.println("Matrizen passen nicht zueinander, du Trottel!");
}else{
  for(...)
    for(...)
}


Ja es gibt else!

Da wie ich bereits erwähnt habe das Ergebnis ein anderes format haben kann als die beiden Ausgangsmatritzen benötigst du wohl eine andere Matritze für dein Ergebnis.

Eine weitere Empfehlung die ich dir geben kann ist, das deine Methoden additions, subtraktions und multiplikationsmethoden einen Rückgabewert vom Typ Matrix haben.

als beispiel:


		Java:In die Zwischenablage kopieren


public Matrix addMatrix(Matrix matrixB){
  if(this.n != matrixB.n || this.m != matrixB.m){
    System.out.println("Matrizen passen nicht zusammen");
    return null;
  }else{
    Matrix result = new Matrix(n,m);
    for(int i = 0; i<result.n;i++){
      for(int j = 0;j<result.m;j++){
        result.matrix[i][j] = matrix[i][j] + matrixB.matrix[i][j];
      }
    }
    return result;
  }
}




		Java:In die Zwischenablage kopieren


public Matrix multiplicateMatrix(Matrix matrixB){
  if(this.m != matrixB.n){
    System.out.println("Matrizen passen nicht zusammen");
    return null;
  }else{
    Matrix result = new Matrix(n,matrixB.m);
    for(int i = 0; i<result.n;i++){
      for(int j = 0;j<result.m;j++){
        result.matrix[i][j] = //here comes the magic Stuff
      }
    }
    return result;
  }
}

*


----------



## nrg (7. Mai 2010)

JohannisderKaeufer hat gesagt.:


> Das return; ist häßlich!



ist ansichtsache. wenn die methode länger ist find ichs schöner am anfang nach einer bedinungen direkt explizit den abbruch zu erzwingen, statt den ganzen sums in einen else zu packen.


----------



## matt65 (7. Mai 2010)

Ja danke für eure Beiträge, aber was heißt das jetzt für meinen Code für Multiplikation, Subtraktion

es passt ja soweit bis auf diese zwei Sachen.

Deine Code ist ja wieder völlig anders.
Kann mir wer sagen, was bei meinem nicht passt.

Danke


----------



## nrg (7. Mai 2010)

seiner ist nicht völlig anders, mir fehlen auch langsam die worte und ich muss jetzt los. tu mir doch einfach den gefallen und kuck dir das tutorial an. danach wirst du das nachvollziehen können und kannst dir die fragen selber beantworten.


----------



## matt65 (8. Mai 2010)

Freilich ist er nicht komplett anders, hat halt andere Bezeichnungen drin; Inhalt ist schon der gleiche.

Bloß komme ich bei meinem nicht weiter trotz des Beitrages:

Hier nochmal meine Methode zur Multiplikation, die fehlerbehaftet ist:

```
public void mulMatrix(int[][] matrix) {
		if (this.matrix.length != matrix.length
				|| this.matrix[0].length != matrix[0].length) {
			System.out
					.println("Bedingung über Gleichheit der  Zeilen- und Spaltenanzahl  nicht erfüllt!");
			return;
		}

		for (int i = 0; i < this.matrix.length; i++) {
			for (int j = 0; j < matrix[0].length; j++) {
				for (int k = 0; k < this.matrix[0].length; k++) {
					this.matrix[i][j] += matrix[i][k] * matrix[k][j];

				}
			}
		}
	}
```

und hier die Ausgabe dazu:


```
//Ausgabe Ergebnis Multiplikation
		        System.out.println("\nErgebnis aus der Multiplikation der Matrizen A * B:");
		        matrixA.getMatrix();
		        matrixA.mulMatrix(matrixB.getMatrix());
		        matrixA.printMatrix();
```

Im Internet hab ich außerdem folgende Lösung für die Multiplikation gefunden


```
c = matMult(a, b);
	    System.out.println("\n\nAugabe:");
	    for (int i = 0; i < c.length; i++){
	      for (int j = 0; j < c[0].length; j++){
	    	  System.out.print(c[i][j] + " ");
	      }
	      System.out.println();
	    }
	    
	  }
	  
	  private static float[][] matMult(float[][]a, float[][]b){
	    
	    float[][] c = new float[a.length][b[0].length];
	    
	    for (int i = 0; i < a.length; i++){
	      for (int j = 0; j < b[0].length; j++){
	        float sum = 0.0f;
	        for (int k = 0; k < b.length; k++){
	          sum = sum + a[i][k] * b[k][j]; 
	        }
	        c[i][j] = sum;
	      }
	    }
	    
	    return c;
	  }
	  
	
	}
```

Vielleicht könnte mir jemand sagen, wie ich das am besten zur Korrektur meines Textes umsetzen kann.
Danke.


----------



## nrg (8. Mai 2010)

das versteh ich nicht. JohannisderKaeufer hat es dir ja oben schon erklärt... ich hab gesagt, du sollst dir erstmal die multiplikationsregeln von matrizen ankucken.... 


> Da wie ich bereits erwähnt habe das Ergebnis ein anderes format haben kann als die beiden Ausgangsmatritzen benötigst du wohl eine andere Matritze für dein Ergebnis.


----------



## matt65 (8. Mai 2010)

Ja ich eure Beiträge doch gelesen, aber mein Problem hat das nicht gelöst:
Jetzt rechne ich auf einmal mit MatrixB, obwohl die dort doch gar nicht bezeichnet wurde,
ich will ja mit den von mir eingegebenen Matrizen rechnen, und das funktioniert eben nicht;
mir ist schon klar das ich Ergebnis in neue Matrix packen muss - Multiplikationsregeln von Matrizen kenne ich auch. (Zeile * Spalte mit Einträgen jeweils skalar multipliziert und anschließend addiert ergibt jeweils einen Eintrag)

Bsp.  4  4      *     3    3
        4  4            3    3            ergibt      (4*3 + 4*3) für ersten Eintrag.


Also hab ich jetzt mal da von    JohannisderKaeufer  eingefügt bin mir aber nicht sicher, was ich jetzt in der Test Klasse für die Durchführung und Ausgabe der result.matrix eingeben muss, dass es funktioniert.


```
public Matrix mulMatrix(Matrix matrixB){
	  if(this.m != matrixB.n){
		    System.out.println("Matrizen passen nicht quadratisch");
		    return null;
		  }else{
		    Matrix result = new Matrix(n,matrixB.m);
		    for(int i = 0; i<result.n;i++){
		      for(int j = 0;j<result.m;j++){
		        result.matrix[i][j] +=  this.matrix[i][j] * matrix[i][j];
		      }
		    }
		    return result;
		  }
	}
```
und das stimmt ja nicht.:

```
//Ausgabe Ergebnis Multiplikation
		        System.out.println("\nErgebnis aus der Multiplikation der Matrizen A * B:");
		        matrixA.getMatrix();
		        matrixB.getMatrix();
		        matrixA.mulMatrix(Matrix matrixB);
		        result.matrix.printMatrix();
```


----------



## nrg (8. Mai 2010)

so das wird jetzt mein letzter post in dem thread. ich kann dir kein java im forum beibringen. das musst du schon selber machen. falls du das tutorial schon gelesen haben solltest, lies es nochmal und nochmal. danach kannste dir das alles selber beantworten.

ausserdem sag ich dir jetzt schon zum dritten mal, dass man so nicht matrizen multipliziert. vergess doch einfach mal komplett die methode und finde erstmal heraus, wie das allgemein funktioniert (Matrizenmultiplikation). das hat noch absolut garnichts mit java zu tun.

du versuchst grad ein haus ohne mörtel zu bauen... das geht halt nicht


----------



## JohannisderKaeufer (8. Mai 2010)

Für die Matrixmultiplikation benötigst du einen Zeilen Vektor und einen Spaltenvektor.

Erstelle hierfür folgende Hilfsmethoden


```
public static int[] getZeilenvektor(int zeile, int[][] theMatrix){
  return theMatrix[zeile];
}

public static int[] getSpaltenvektor(int spalte, int[][] theMatrix{
  int[] result = new int[theMatrix.length];
  for(int i=0;i < theMatrix.length;i++){
    result[i] = theMatrix[i][spalte];
  }
return result;
}
```

Nun werden jeweils ein spalten und zeilenvektor miteinander "multipliziert"

Hierfür könnte sich doch folgende Methode eignen:

```
public static int multipliziereZeilenundSpaltenVektor(int[] zeilenVektor, int[] spaltenVektor){
int result = 0;
for(int i = 0; i<zeilenVektor.length;i++){
  result = result + zeilenVektor[i]*spaltenVektor[i];
}
return result;
}
```

Um nun zu deinem Ergebnis zu kommen mußt du für das Feld (1,1) deiner Ergebnismatrix
den zeilenVektor 1 von deiner ersten Matrix nehmen und den SpaltenVekor 1 von deiner zweiten Matrix und diese beiden miteinander "multiplizieren".

Den Code den du gefunden hast, der macht das selbe nur in einer komprimierten Art und Weise.


----------



## matt65 (8. Mai 2010)

okay, cool das du dir soviel Arbeit gemacht hast.
also ich ging halt bis jetzt von einer quadrat. Matrix aus, aber deins schließt mehr Fälle ein (z.B. Vektor)

Ist das richtig, dass ich jetzt dann sowas hier zur Ausgabe brauch, wobei ich noch die einzelnen Methoden erzeugen muss (dachte deins wären die schon .getSpaltenvektor() ?), um anschließend die Multiplikation durchführen zu können. Aber muss auch schon die eigentliche Methode zur Multiplikation drinlassen, das es geht oder genügen die zwei Methoden schon; kann ich da die nehmen welche ich gefunden habe, oder ist diese nicht nehmbar für meine Zwecke?


```
//Ausgabe Ergebnis Multiplikation
		        System.out.println("\nErgebnis aus der Multiplikation der Matrizen A * B:");
		        matrixA.getSpaltenvektor();
		        matrixB.getZeilenvektor();
		        result.printMatrix();
```
Danke


----------

