Werte einer anderen Klasse übergeben und Werte zurückbekommen

[ChrisB]

Guten Tag,
ich habe 2 Klassen, einmal PicturePanel und einmal Berechnungen.
Ich möchte vom PicturePanel zu Berechnungen Werte übergeben, dass klappt auch.
Möchte aber berechnete Werte von Berechnungen wieder zur PicturePanel Klasse wieder übergeben, die dort dann benutzt werden.

Hier meine 1 Klasse:

    import javax.imageio.*;
    import java.awt.*;
    import java.net.*;
    import java.io.*;
    import java.awt.event.*;
    import javax.swing.ToolTipManager;


     
     
public class PicturePanel extends JPanel
{
  private Image background;
  int xpos, ypos;
  double Rven=0.0, Uges=0.0, I=0.0;
  String[] arrayR = new String [7];
  
  
  
  public PicturePanel() {
    super(new GridBagLayout());
    ToolTipManager.sharedInstance().registerComponent(this);
    
    try {  
      background = ImageIO.read(getClass().getResource("background.png"));
    }
    catch(IllegalArgumentException iae) {
      JOptionPane.showMessageDialog(this, "Grafikdatei nicht gefunden!
"+iae.getMessage());
      System.exit(-1);
    }
    
    catch(IOException ioe) {
      JOptionPane.showMessageDialog(this, "Fehler beim Einlesen einer Grafikdatei!
"+ioe.getMessage());
      System.exit(-1);
    }    
    
    
    
    for (int i=0;i<7 ;i++ ) {
      if (arrayR** == null) 
      {
        arrayR** = "0.0";
      } 
      
    } 
    
    
    
    
    addMouseListener(new MouseAdapter()
    {  
      
      public void mousePressed(MouseEvent event){
        
        try {
          
          
          xpos = event.getX();
          ypos = event.getY();
          
          System.out.println(xpos + " " + ypos);
          
          // Voltmeter Gesamt
          
          if ((xpos >= 466)  && (xpos <= 492) && (ypos >= 188) && (ypos <= 212)) 
          {
            Uges = Double.parseDouble(JOptionPane.showInputDialog(null,"Geben Sie die Gesamt Spannung (Uges) ein:","Widerstandeingabe", JOptionPane.PLAIN_MESSAGE));
          } 
          
          
          // Ventilator
          
          else
          if ((xpos >= 917)  && (xpos <= 948) && (ypos >= 119) && (ypos <= 150))  
          {
            Rven = Double.parseDouble(JOptionPane.showInputDialog(null,"Geben Sie die Größe des Ventilator Widerstandes ein:","Widerstandeingabe", JOptionPane.PLAIN_MESSAGE));
          }  
          
          
          // Widerstände
          
          if ((xpos >= 90)  && (xpos <= 118) && (ypos >= 86) && (ypos <= 100)) 
          {
            arrayR[0] = JOptionPane.showInputDialog(null,"Geben Sie die Größe vom Widerstand R1 ein:","Widerstandeingabe", JOptionPane.PLAIN_MESSAGE);
          }
          else
          if ((xpos >= 239)  && (xpos <= 267) && (ypos >= 86) && (ypos <= 100))  
          {
            arrayR[1]  = JOptionPane.showInputDialog(null,"Geben Sie die Größe vom Widerstand R2 ein:","Widerstandeingabe", JOptionPane.PLAIN_MESSAGE);
          }
          else
          if ((xpos >= 387)  && (xpos <= 415) && (ypos >= 86) && (ypos <= 100)) 
          {
            arrayR[2]  = JOptionPane.showInputDialog(null,"Geben Sie die Größe vom Widerstand R3 ein:","Widerstandeingabe", JOptionPane.PLAIN_MESSAGE);
          }
          else
          if ((xpos >= 536)  && (xpos <= 564) && (ypos >= 86) && (ypos <= 100)) 
          {
            arrayR[3]  = JOptionPane.showInputDialog(null,"Geben Sie die Größe vom Widerstand R4 ein:","Widerstandeingabe", JOptionPane.PLAIN_MESSAGE);
          }
          else
          if ((xpos >= 685)  && (xpos <= 712) && (ypos >= 86) && (ypos <= 100)) 
          {
            arrayR[4]  = JOptionPane.showInputDialog(null,"Geben Sie die Größe vom Widerstand R5 ein:","Widerstandeingabe", JOptionPane.PLAIN_MESSAGE);
          }
          else
          if ((xpos >= 833)  && (xpos <= 862) && (ypos >= 86) && (ypos <= 100))  
          {
            arrayR[5]  = JOptionPane.showInputDialog(null,"Geben Sie die Größe vom Widerstand R6 ein:","Widerstandeingabe", JOptionPane.PLAIN_MESSAGE);
          }
          
          new Berechnungen(arrayR, Rven, Uges); 
          
        } catch(Exception e) {
         
        }  
        
      }
    }) ;
    
    addMouseMotionListener(new MouseMotionAdapter()
    {
      public void mouseMoved(MouseEvent event){
        xpos = event.getX();
        ypos = event.getY();
        
        // Voltmeter Gesamt
        
        if ((xpos >= 466)  && (xpos <= 492) && (ypos >= 188) && (ypos <= 212)) 
        {
          setToolTipText("<html>Uges"+"<br>"+Uges+" Ohm"+"</html>"); 
        } 
        
        
        // Ventilator
        
        else 
        if ((xpos >= 917)  && (xpos <= 948) && (ypos >= 119) && (ypos <= 150))  
        {
          setToolTipText("<html>Ventilator"+"<br> Rven =  "+ Rven +" Ohm"+"<br> P =  "+ "" +" W"+"</html>");
        }  
        
        // Widerstände
        
        else
        if ((xpos >= 90)  && (xpos <= 118) && (ypos >= 86) && (ypos <= 100)) 
        {
          setToolTipText("<html>R1"+"<br>"+arrayR[0]+" Ohm"+"</html>"); 
        }
        else
        if ((xpos >= 239)  && (xpos <= 267) && (ypos >= 86) && (ypos <= 100)) 
        {
          setToolTipText("<html>R2"+"<br>"+arrayR[1]+" Ohm"+"</html>");
        }
        else
        if ((xpos >= 387)  && (xpos <= 415) && (ypos >= 86) && (ypos <= 100)) 
        {
          setToolTipText("<html>R3"+"<br>"+arrayR[2]+" Ohm"+"</html>");
        }
        else
        if ((xpos >= 536)  && (xpos <= 564) && (ypos >= 86) && (ypos <= 100)) 
        {
          setToolTipText("<html>R4"+"<br>"+arrayR[3]+" Ohm"+"</html>");
        }
        else
        if ((xpos >= 685)  && (xpos <= 712) && (ypos >= 86) && (ypos <= 100)) 
        {
          setToolTipText("<html>R5"+"<br>"+arrayR[4]+" Ohm"+"</html>");
        }
        else
        if ((xpos >= 833)  && (xpos <= 862) && (ypos >= 86) && (ypos <= 100))  
        {
          setToolTipText("<html>R6"+"<br>"+arrayR[5]+" Ohm"+"</html>");
        }
        
        
        // Amperemeter
        
        else 
        if 
        (  
        ((xpos >= 167)  && (xpos <= 192) && (ypos >= 81) && (ypos <= 104)) ||
        ((xpos >= 316)  && (xpos <= 339) && (ypos >= 81) && (ypos <= 104)) ||
        ((xpos >= 465)  && (xpos <= 489) && (ypos >= 81) && (ypos <= 104)) ||
        ((xpos >= 612)  && (xpos <= 636) && (ypos >= 81) && (ypos <= 104)) ||
        ((xpos >= 764)  && (xpos <= 784) && (ypos >= 81) && (ypos <= 104)) ||
        ((xpos >= 900)  && (xpos <= 925) && (ypos >= 81) && (ypos <= 104))
        )  
        {
          setToolTipText("<html>I"+"<br>"+I+" Ampere"+"</html>");
        } 
        
        // Voltmeter
        
        else
        if ((xpos >= 82)  && (xpos <= 117) && (ypos >= 10) && (ypos <= 35))  
        {
          setToolTipText("<html>U1"+"<br>"+ ""+" V"+"</html>");
        }
        else
        if ((xpos >= 241)  && (xpos <= 265) && (ypos >= 10) && (ypos <= 35))  
        {
          setToolTipText("<html>U2"+"<br>"+ ""+" V"+"</html>");
        } 
        else
        if ((xpos >= 389)  && (xpos <= 415) && (ypos >= 10) && (ypos <= 35))  
        {
          setToolTipText("<html>U3"+"<br>"+ ""+" V"+"</html>");
        } 
        else
        if ((xpos >= 536)  && (xpos <= 564) && (ypos >= 10) && (ypos <= 35))  
        {
          setToolTipText("<html>U4"+"<br>"+ ""+" V"+"</html>");
        } 
        else
        if ((xpos >= 686)  && (xpos <= 712) && (ypos >= 10) && (ypos <= 35))  
        {
          setToolTipText("<html>U5"+"<br>"+ ""+" V"+"</html>");
        } 
        else
        if ((xpos >= 835)  && (xpos <= 861) && (ypos >= 10) && (ypos <= 35))  
        {
          setToolTipText("<html>U6"+"<br>"+ ""+" V"+"</html>");
        } 
        
        // Spannung Ventilator
        
        else 
        if ((xpos >= 918)  && (xpos <= 945) && (ypos >= 163) && (ypos <= 185))  
        {
          setToolTipText("<html>Uven"+"<br>"+ ""+" V"+"</html>");
        }
        
        
        else
        {
          setToolTipText("");
        }      
        
        
      } 
    });
    
    
  }
  
  
  
  
  @Override
  protected void paintComponent(Graphics g) {
    super.paintComponent(g);
    if(background != null) {
      g.drawImage(background, 0, 0, this);
      
    }
  }
  
}

Hier meine 2 Klasse:

{
  
  
  public Berechnungen(String[] arrayR, double Rven, double Uges) {
    
    double arrayU[] = new double[7]; 
    
    double 
    Rges = Rven,   
    I = 0.0,       
    Uven = 0.0,    
    Lven = 0.0;    
    
    for (int i=0;i<7 ;i++ ) {
      Rges = Rges + (Double.parseDouble(arrayR**));
    } 
    
    
    I = Uges / Rges;
    
    for (int i=0;i<7 ;i++ ) {
      arrayU** = (Double.parseDouble(arrayR**) * Uges) / Rges; 
      
    } 
    
    Uven = (Rven * Uges) / Rges;
    
    Lven = Rven * Math.pow(Uges, 2);
    
    
    
  }
  
}```

Möchte die Werte: arrayU, Lven, Uven und I wieder PicturePanel zurückgeben.
Wie stelle ich das an?

[TheUnregistered]

Für Rückgaben aus Funktionen wird üblicherweise der Rückgabewert verwendet.

Hat man eine Funktion

   int z=x+y;
}``` 
passiert da nicht viel. Verwendet man nun einen rückgabewert
```public int berechne (int x int y){
   int z=x+y;
   return z;
}``` 
kann nun der Aufrufer das Ergebnis verwenden.

Will man nun mehr als nur einen einfachen Datentyp zurückgeben, muss man sich dafür ein passende Klasse erstellen die man zurückgibt.
Diese Klasse hat dann nur die Felder (Werte) die man übergeben möchte und passende Setter und Getter

[EikeB]

Ich würde die Berechnungen-Klasse etwas anders aufziehen. So wie es aussieht ist das eine Klasse die nur dazu dient etwas auszurechnen, richtig?
Dann würde ich die Klasse zu einer Util Klasse umfunktionieren, bspw. so:

public class Berechnungen /* Der Name ist nicht ganz optimal */
{

  public static double[] calculateArrayU(...) {
    double arrayU = new double[7];
    // hier arrayU berechnen
    return arrayU;
  }

  public static double calculateLven(...)
  {
    double Lven = 0.0;
    // hier Lven berechnen
    return Lven;
  }

  ...
}

Dabei können deine Methode sich gerne auch gegenseitig nutzen. Um das jetzt vernünftig zu strukturieren fehlen mir die Kenntnisse die deine Werte voneinander abhängen, bzw. sich gegenseitig berechnen.

In der PicturePanel klasse kannst du das dann so nutzen:
double Lven = Berechnungen.calculateLven(... benötigte Parameter ...);

[ChrisB]

Gibt es nicht noch eine andere Möglichkeit diese Werte zu übergeben, eventuell über den gleichen Weg wie ich die Werte übergeben habe?
Weil ehrlich gesagt ist mir das was du mit eigener Klasse die nur die FElder hat die man übergeben möchte mit passenden Setter und Getter zu hoch.

[TheUnregistered]

Da man nur einen Rückgabewert hat, kann man nur ein Objekt zurück geben, du willst aber 4 Objekte zurückgeben, das ist aber nicht möglich. Somit musst du dir ein Transferobjekt dafür nehmen (welches diese 4 Objekte beinhält)

[ChrisB]

Mhh
ich frage mich gerade ob das eine gute Idee war eine weitere Klasse zu erstellen für die Berechnungen?

EDIT 1:

Oh habe den Beitrag von EikeB übersehen.
Was für Parameter müssen denn hier zum Beispiel rein:

public static double[] calculateArrayU(...)

EDIT 2:

Müsste das so aussehen?

{
  
  public static double[] calculateArrayU(double Uges, double Rges) 
  {
    double arrayU = new double[7];
    for (int i=0;i<7 ;i++ ) {
      arrayU** = (Double.parseDouble(arrayR**) * Uges) / Rges; 
      return arrayU;
    }
  }
  
  public static double calculateRges(double arrayU)
  {
    for (int i=0;i<7 ;i++ ) {
      Rges = Rges + (Double.parseDouble(arrayR**));
    } 
  }
  
  public static double calculateI(double Uges, double Rges)
  {
    double I;
    I = Uges / Rges;
  }
  
  
  
  public static double calculateUven(double Rven, double Uges, Double Rges)
  {
    double Uven;
    Uven = (Rven * Uges) / Rges;
  }
  
  public static double calculateLven(double Uges)
  {
    double Lven = 0.0;
    Lven = Rven * Math.pow(Uges, 2);
    return Lven;
  }
  
  
  
  
  
  
  
  
  
}
  
}```

[SlaterB]

nebenbei ist der gepostete Code höchst bedenklich, mit unzähligen Code-Wiederholungen und noch viel mehr direkten Positionsangaben

        if ((xpos >= 685)  && (xpos <= 712) && (ypos >= 86) && (ypos <= 100))
        {
          arrayR[4]  = JOptionPane.showInputDialog(null,"Geben Sie die Größe vom Widerstand R5 ein:","Widerstandeingabe", JOptionPane.PLAIN_MESSAGE);
        }
	[..]
        if ((xpos >= 685)  && (xpos <= 712) && (ypos >= 86) && (ypos <= 100))
        {
          setToolTipText("<html>R5"+"<br>"+arrayR[4]+" Ohm"+"</html>");
        }
	[..]
	if ((xpos >= 686)  && (xpos <= 712) && (ypos >= 10) && (ypos <= 35))  
        {
          setToolTipText("<html>U5"+"<br>"+ ""+" V"+"</html>");
        } 

wenn es ein Hintergrundbild gibt, auf dem nunmal irgendwas fertig gemalt ist, kommt man um Pixelgenauigkeit nicht herum,
aber das kann man alles viel besser organisieren

offensichtlich gibt es 6 Haupt-Dinger, von was auch immer, ein Array (statt Einzelvariablen) schon ein zögerlicher Anfang,
aber wenn du jedes Array-Element einzeln mit Index ansprechen musst, dann auch nicht so viel Unterschied,

ins Array gehören Objekte einer eigenen Klasse, in der du mehr Informationen sammeln kannst, etwa der so wichtige beginnende x-Wert

aus

                    if ((xpos >= 90) && (xpos <= 118) && (ypos >= 86) && (ypos <= 100))
                    {
                        setToolTipText("<html>R1" + "<br>" + arrayR[0] + " Ohm" + "</html>");
                    }
                    else if ((xpos >= 239) && (xpos <= 267) && (ypos >= 86) && (ypos <= 100))
                    {
                        setToolTipText("<html>R2" + "<br>" + arrayR[1] + " Ohm" + "</html>");
                    }
                    else if ((xpos >= 387) && (xpos <= 415) && (ypos >= 86) && (ypos <= 100))
                    {
                        setToolTipText("<html>R3" + "<br>" + arrayR[2] + " Ohm" + "</html>");
                    }
                    else if ((xpos >= 536) && (xpos <= 564) && (ypos >= 86) && (ypos <= 100))
                    {
                        setToolTipText("<html>R4" + "<br>" + arrayR[3] + " Ohm" + "</html>");
                    }
                    else if ((xpos >= 685) && (xpos <= 712) && (ypos >= 86) && (ypos <= 100))
                    {
                        setToolTipText("<html>R5" + "<br>" + arrayR[4] + " Ohm" + "</html>");
                    }
                    else if ((xpos >= 833) && (xpos <= 862) && (ypos >= 86) && (ypos <= 100))
                    {
                        setToolTipText("<html>R6" + "<br>" + arrayR[5] + " Ohm" + "</html>");
                    }

könnte mit wenig Arbeit

for (int i=0; i<wiederstaende.length; i++) {
  Wiederstand w = wiederstaende**;
  if ((xpos >= w.x) && (xpos <= w.x+28) && (ypos >= 86) && (ypos <= 100))
  {
       setToolTipText("<html>R"+ (i+1) + "<br>" + w.r + " Ohm" + "</html>");
  }
}

werden, es braucht nur ein Array der neuen Klasse,
in 6 Zeilen gefüllt mit

dinge[0] = new Ding(90, ..); 

was sich eben so zu sammeln lohnt, vielleicht gar nicht mehr als nur der x-Wert am Anfang,
der r-Wert wird ja eingelesen usw.

weniger Fehler und bessere Änderungsmöglichkeiten,
falls du den Text oder x-Breite oder die y-Position ändern willst, dann nur an einer Stelle, statt wiederholt in 6 ifs,

oder noch schlimmer an weiteren Stellen ganz woanders im Code, man stelle sich vor ein x würde sich ändern…

dies ist sehr wichtig, Code- und Werte-Verdopplung ist einer der wesentlichen Fehler die man machen kann
(unter denen noch funktionierender Programme, bei denen kein Compiler meckert)

@ChrisB

ich frage mich gerade ob das eine gute Idee war eine weitere Klasse zu erstellen für die Berechnungen

Berechnungen ist doch schon eine separate Klasse, was noch mehr? Datencontainer gewiss, wobei auch Berechnungen die Werte in Variablen halten könnte,

[TheUnregistered]

Ich hatte mir deinen Code nicht näher angeschaut (da er sehr unübersichtlich ist und es für die Fragestellung nicht so auf deinen Code ankam) aber da kann ich @SlaterB nur zustimmen.

Zu deinem zweiten Edit
Ja das kann dann so aussehen, da hast du dann für jede Berechnung eine eigene Funktion, welche immer nur einen Rückgabewert hat, was somit passt.
Auch macht es den Code verständlicher, als nur eine Funktion die viele verschiedene Sachen macht.