FRAGE:

Schreibe eine Klasse "Matrix" in Java/Processing, die die folgende Schnittstelle iMatrix
implementiert und mit show() die gespeicherte zweidimensionale Integer-Matrix im Grafik-Fenster anzeigt.
Dieses zweidimensionale Integer-Array wird bei Erzeugen eines Objektes dem Konstruktor übergeben 
und eine Referenz der Matrix soll im Objekt als private Attribut gespeichert werden.
Die Darstellung soll die Zahlen in den Zeilen und Spalten der Matrix in einem rechteckigen Schema darstellen. 
Die Matrix soll zudem so angezeigt werden, dass Einer, Zehner usw. untereinander in Flucht dargestellt werden.

Hier ist die Schnittstelle:

public interface iMatrix
{     
    public abstract void show();
}

ANTWORT:

Hier ist eine mögliche Implementierung der Klasse "Matrix" in Java/Processing, 
die die Schnittstelle iMatrix implementiert und eine zweidimensionale 
Integer-Matrix im Grafik-Fenster anzeigt:

public class Matrix implements iMatrix {
  
  private int[][] matrix;
  private PApplet parent;
  
  public Matrix(PApplet parent, int[][] matrix) {
    this.parent = parent;
    this.matrix = matrix;
  }
  
  public void show() {
    int numRows = matrix.length;
    int numCols = matrix[0].length;
    
    int cellSize = 40;
    int startX = 50;
    int startY = 50;
    
    parent.textSize(20);
    parent.noStroke();
    
    for (int i = 0; i < numRows; i++) {
      for (int j = 0; j < numCols; j++) {
        int value = matrix[i][j];
        int x = startX + j * cellSize;
        int y = startY + i * cellSize;
        
        parent.fill(255);
        parent.rect(x, y, cellSize, cellSize);
        
        parent.fill(0);
        parent.text(value, x + cellSize/2, y + cellSize/2);
      }
    }
  }
}

Die Klasse nimmt im Konstruktor eine Referenz auf das Processing-Objekt 
parent sowie ein zweidimensionales Integer-Array matrix als Argumente. 
Die Matrix wird als private Attribut matrix gespeichert.

Die Methode show() zeichnet die Matrix im Grafik-Fenster. Die Größe der 
Zellen wird auf cellSize festgelegt, der Abstand zum linken und oberen 
Rand auf startX und startY. Die Methode iteriert über die Zeilen und 
Spalten der Matrix und zeichnet für jede Zelle ein weißes Rechteck mit 
schwarzer Zahl in der Mitte.

Die Zahlen werden mit der Processing-Methode text() in der Mitte der 
Zelle platziert und mit der Methode textSize() auf 20 Pixel gesetzt. 
Die Methode noStroke() sorgt dafür, dass keine Umrandung der Zellen gezeichnet wird.

Um die Klasse zu nutzen, kann ein Objekt von Matrix mit einer Matrix-Referenz 
erstellt und die show-Methode aufgerufen werden:

int[][] matrix = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} };
Matrix matrixObj = new Matrix(this, matrix);
matrixObj.show();

Code 0-1: Frage an ChatGPT und dessen Antwort.

import java.util.Random;
//Random zufall = new Random(System.currentTimeMillis());
Random z = new Random(0);

int[][] m = new int[60][60];

public boolean istGeerntet(int i, int k, int[][] m)
{
     if(m[i-1][k]==1 && m[i+1][k]==1
     && m[i][k+1]==1 && m[i][k-1]==1)  
         return true;
     else
         return false;
}

public boolean mussStehen(int i, int k, int[][] m)
{
     if(i>0 && m[i-1][k]==2) return true;
     if(i<m.length-1 && m[i+1][k]==2) return true;
     if(k>0 && m[i][k-1]==2) return true;
     if(k<m.length-1 && m[i][k+1]==2) return true;
     return false;
}

public void schritt(int[][] m)
{
    for(int ii=0;ii<m.length*m.length;ii++)
    {
                  int i = z.nextInt(m.length);
                  int k = z.nextInt(m.length);
                  if(m[i][k]==2)
                  {
                       if(istGeerntet(i,k,m))
                          m[i][k]=0;
                  }
                  else if(m[i][k]==1)
                  {
                       if(!mussStehen(i, k, m))
                       {
                           if(z.nextBoolean())
                           {
                                if(z.nextBoolean())
                                {
                                    if(i+1<m.length-1 && m[i+1][k]==0)
                                    {
                                        m[i][k]=0;
                                        m[i+1][k]=1;
                                    }
                                }
                                else
                                {
                                    if(i-1>=0 && m[i-1][k]==0)
                                    {
                                        m[i][k]=0;
                                        m[i-1][k]=1;
                                    }
                                }
                           }
                           else
                           {
                                if(z.nextBoolean())
                                {
                                    if(k+1<m.length-1 && m[i][k+1]==0)
                                    {
                                        m[i][k]=0;
                                        m[i][k+1]=1;
                                    }
                                }
                                else
                                {
                                    if(k-1>=0 && m[i][k-1]==0)
                                    {
                                        m[i][k]=0;
                                        m[i][k-1]=1;
                                    }
                                }
                           }
                       }
                  }
    }
}

public void setup()
{
    for(int i=0;i<300;i++)
       m[z.nextInt(m.length)][z.nextInt(m.length)]=1;
    for(int i=0;i<100;i++)
       m[z.nextInt((m.length)/3)*3+1][z.nextInt((m.length)/3)*3+1]=2;
       
    size(600,600);
    frameRate(30);
}

public void draw()
{
    schritt(m);
    
    
    for(int i=0;i<m.length;i++)
    {
          for(int k=0;k<m[i].length;k++)
          {
                float x = (float)k*width/(float)m.length;
                float y = (float)i*width/(float)m.length;
                
                if(m[i][k]==0)
                   fill(0);
                else if(m[i][k]==1)
                   fill(255,0,0);
                else
                   fill(0,255,0);
                   
                rect(x,y,width/(float)m.length,width/(float)m.length);   
                
          }
    }
    
}

Code 0-2: "Fresser" -- einfaches Beispiel für Schwarmverhalten als Stand-Alone-Simulation mit Processing.

void receive( byte[] data, String ip, int port ) 
{    
  String message = new String( data );  
  println( "receive: \""+message+"\" from "+ip+" on port "+port );  
...

Code 0-3: UDP-Callback-Methode receive(), insbesondere print-Befehl, der in der Konsole die Roh-Nachricht anzeigt.

//Board: ESP32 SUPER MINI
//Auswählen in ISE: ESP32C3 Dev Module
//USB CDC ON BOOT DISABLED
//Meldet sich aber als ESP32S3
#include <WiFi.h>
#include "AsyncUDP.h"

//Hier Kalibrieren:
#define BAHN_MIN 992.0
#define BAHN_MAX 2895.0

#define ENTF_MIN 54.0
#define ENTF_MAX 2895.0

#define NORMAL_SPEED_LEFT 200 //100...255
#define NORMAL_SPEED_RIGHT 200 //100...255
#define SPEED_OFFSET_LEFT 10;
#define SPEED_OFFSET_RIGHT 10;

Code 0-4: Erste Zeilen des Arduino-Projekts ESP32C3_SUPER_MINI_ARDUINO_OOP_304 (gehört in den Arduino-Ordner /home/fhbstud/Arduino/ !!!)

long T = System.currentTimeMillis(); //Absolute Systemzeit in Millisekunden
long Tdiff = 1000; //Differenz zwischen den Aktualisierungen der Sensorwerte
void receive(...)
{
    long Tneu = System.currentTimeMillis();
    Tdiff = Tneu - T;
    T = Tneu;
    //....
}

Code 0-5: Code-Snippet für Java/Processing zur quantitativen Erfassung der Totzeit in Millisekunden.

eI = eI + e*dt;

eD = (e - e_alt)/dt;

Code 0-6: Code-Snippet für Java/Processing zur Bildung von I- und D-Anteil der Regelabweichung.