Java stapeldiagram baserat på int värden från annan metod?

Om jag förstår dig rätt så har du två metoder i samma klass, en som skapar data och paintComponent som ska visa datan? Datan borde i så fall tillhöra klassen, dvs. den ska deklareras utanför metoderna. Lite pseudo-kod som exempel:

class C {
  private int data[];

  void collectData() {
    // Samla in data och lagra i data-variabeln.
  }

  void paintComponents(Graphics g) {
    // Rita up komponenten med hjälp av datan i data-variabeln.
  }
}

En instans av en klass är ju lite förenklat en samling av data och metoder som opererar på den datan. Metoderna kan skapa temporära variabler för att hålla temporär data, men när metoderna kört klart så försvinner oftast den datan om man inte lagrar den i klassen själv eller någon annanstans.

Edit: Så länge som datan bara ska hanteras inom klassen så behöver du förresten inte deklarera den som public (och bör inte göra det heller). Dvs. deklarera klass-variablerna som private om du inte har en väldigt bra orsak att inte göra det.

Av det du har skrivit så ska du göra följande:
Skapa en klass som heter Rektangel
Skapa en konstruktor till denna klass som tar dessa parametrar: bredd, höjd och färg.
Skapa två metoder, en för att sätta X-position och en för att sätta Y-position
Skapa fem metoder för att hämta: bredd, höjd, färg, omkrets och area.

Sen skapar du upp två instanser från denna klass, ex:
Rektangel rek1 = new Rektangel(valfri_bredd,valfri_höjd,valfri_färg);
rek1.setXPosition(valfri_X_position);
rek1.setYPosition(valfri_Y_position);

Sen ritar du ut rektangeln i din paintComponent med hjälp av värdena som ligger i objektet rek1.

Ja, du ritar ut det i paintComponent(Graphics g) med hjälp av Graphics-argumentet "g".

Eftersom du har gjort metoder på Rektangel så kan du hämta ut alla värden som du har satt (bredd,höjd,x-position,y-position) som behövs för att rita ut objektet. Steget efter det är väl att färga till rätt färg som du också har satt.

Exempelvis metoden g.fillRect() är specifierad enligt följande:
fillRect(int x, int y, int width, int height)
Källa: http://download.oracle.com/javase/1.4.2/docs/api/java/awt/Gra...

Den vill alltså ha värden som din rektangel har: x-position, y-position,bredd, höjd.

Du är på rätt väg men du har glömt en otroligt viktig punkt: instansvariabler.
Dessutom använder du koden åt fel håll:
Metoderna tar emot argument som du specifierar på "typnivå" (ex: int, string). Du måste sedan kalla på metoden med ett värde av rätt typ (ex: 10, "hejsan")

Exempel:
[code]
public class Rektangel {
//Instansvariabler
int height = 0;
int width = 0;

//Konstruktor som gör ett objekt av typen "Rektangel". Två argument av typen "int".
public Rektangel(int h, int w)
{
//Sätt instansvariablerna till värdena som vi får in i konstruktorn
height = h;
width = w;
}
}

//I någon annan klass kan du sedan skapa upp en rektangel enligt följande:
Rektangel rek1 = new Rektangel(10,20);
//rek1 är nu ett objekt av typen "Rektangel" med värdena "height = 10" och "width = 20";

Du får nog tänka om lite. Vad du vill ha är en panel som har två rektanglar + test, men som du har skrivit det i din kod så ärver rektangel-klassen från JPanel. Rektangeln är alltså panelen, vilket inte riktigt är vad du vill ha.

Istället så vill du ha en huvudklass som är själva panelen, och en separat Rektangel-klass för rektanglarna. Panel-klassen skapar sedan helt enkelt två Rektangel-objekt och använder dessa.

Du har sedan egentligen två val när det gäller att rita ut rektanglarna. Antingen så använder du rektanglarnas metoder för att ta reda på hur de ska ritas ut och ritar ut dem i panelen. Ett annat alternativ är att ge rektangel-klassen en egen paint-metod, och skicka Graphics-objektet från panelen till dem. Rektanglarna ritar i så fall ut sig själva. Båda alternativen har sina för- och nackdelar, men det spelar inte så stor roll vilket du väljer i det här fallet.

Lite psudo-kod för hur det kan se ut:

class Panel extends JPanel {
    private Rektangel rektangel1;
    private Rektangel rektangel2;

    public void paintComponent(Graphics g) {
      rektangel1.paint(g);
      rektangel2.paint(g);
      // Rita text, etc.
    }
}

class Rektangel {
    // Rektangelns variabler och metoder.

    public void paint(Graphics g) {
      // Rita ut rektangeln med hjälp av g.
    }
}

Ett tips är förresten att du gärna får omge din kod med [ code ] och [/ code ] (utan mellanslag), det gör din kod mer lättläst.

public class Rektangel extends JPanel {


    //Instanvariabler.
    public int bredd;
    public int höjd;
    public int xposition;
    public int yposition;
    public int omkrets;
    public int area;
    
    
    //Konstruktor.
    public Rektangel(int b, int h, int x, int y, Color c){
    
        bredd = b;
        höjd = h;
        xposition = x;
        yposition = y;  
        
    }//Slut konstruktor.
     
    
    //Metod för att sätta X koordinat.
    public void setXPostition(int x){
        x = 10;
    }    
    
    //Metod för att sätta Y koordinat.
    public void setYPostition(int y){
        y = 10;
    }
    

    //Metod för hämta bredd.
    public void getBredd(int b){
        
    }

    //Metod för hämta höjd.
    public void getHöjd(int h){
        
    }

    //Metod för att hämta färg.
    public void getFärg(Color c, Color d){
        c = Color.YELLOW;
        d = Color.RED;
    }
    
    //Metod för att beräkna omkrets.
    public void getOmkrets(int o, int b, int h){
        
    }

    //Metod för att beräkna area.
    public void getArea(int a, int h){
       
    }


   
  public void paintComponent(Graphics g) {

        super.paintComponent(g);
       
        
   }//Slut paintComponent.
}//Slut klass Rektangel.

Konstruktorn ser bra ut. Men dina andra metoder har små fel.

Exempelvis:
public void setYPostition(int y){
y = 10;
}

Denna metod använder du på detta sätt:
rektangel1.setYPosition(20);

Vad som händer är att 20 kommer ändras till 10. Inget mer.
Du ska istället skriva:

public void setYPostition(int y){
yposition = y;
}

När man då anropar metoden genom rektangel1.setYposition(20); så kommer yposition att uppdateras till 20 för objektet rektangel1.

Kolla vad "perost" skrev.

Jag tror inte det är meningen att du ska göra en JPanel av din Rektangelklass.

Du ska snarare ha din vanliga Main-klass och rita på en panel där.
Väl i Mainmetoden så instansierar du ett par rektanglar som du sedan kan rita ut i paintComponent().

Om jag ska vara ärlig så känns det som en för stor uppgift att börja med. För många metoder och annat som gör det grötigt och svårt att se helheten om man är ny.

Börja enkelt:
Använd inte en egen "Rektangel"-klass. Rita bara ut en rektangel.

Rektangel-klassen kan man lägga på i efterhand då den _endast_ ska innehålla egenskaper som beskriver objektet (i detta fall en Rektangel) inte något annat.

Ja, jag förstår.
Koda vidare och skriv om det fortsätter strula.

public class Rektangel{

    //Deklarerar instanvariabler.
    public int bredd;
    public int höjd;
    public int xpos;
    public int ypos;
  
    //Konstruktor som "sätter" default värde.
    Rektangel(){

        bredd = 10;
        höjd = 10;
        xpos = 0;
        ypos = 0;
    }//Slut konstruktor.

     //Konstruktor.
    Rektangel(int b, int h, int x, int y){

        bredd = b;
        höjd = h;
        xpos = x;
        ypos = y;
    }//Slut konstruktor.



    public void setXPos(int x){
        xpos = 10;
    }

    public int getXPos(int x){
        return xpos;
    }

    public void setYPos(int y){
        ypos = 10;
    }

    public int getYPos(int y){
        return ypos;
    }

    public int getBredd(int b){
        return bredd;
    }

     public int getHöjd(int h){
        return höjd;
    }

     public int getArea(){
        return (höjd * bredd);
    }

     public int getOmkrets(){
        return (bredd + bredd + höjd + höjd);
    }

}//Slut klass Rektangel.

public class RektangelTest extends JFrame {

     public static void main (String [] args){

         Panel panel = new Panel();//Skapar panel.
         JFrame application = new JFrame();//Skapar JFrame att sätta panelen på.

         //JFrame inställningar.
         application.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
         application.add(panel);
         application.setSize(300, 300);
         application.setVisible(true);

     }//Slut huvumetod.
}//Slut klass RektangelTest.

public class Panel extends JPanel {

     public void paintComponent(Graphics g) {

        super.paintComponent(g);
        setBackground(Color.white);

        Rektangel r1 = new Rektangel();//Skapar objekt r1 av klass Rektangel.
        Rektangel r2 = new Rektangel();//Skapar objekt r1 av klass Rektangel.

        //HÄR ÄR PROBLEMET. VILL ANROPA METODERNA FRÅN KLASS REKTANGEL 
        //FÖR ATT KUNNA RITA UPP TVÅ REKTANGLAR.


    }//Slut metod paintComponent.
}//Slut klass Panel.

Ser mycket bättre ut!

Angående några av metoderna på Rektangel:
getXPos(int x) // Du använder aldrig variabeln "x" här. Dessutom ska du hämta värdet i "xpos", du ska inte sätta det, så du kan skippa argumentet.
setXPos(int x) // Du borde sätta "xpos" till "x" istället för att hårdkoda "xpos" = 10.

Jag tror inte det är optimalt att instansiera (när du använder "new"-nyckelordet) i paintComponent.
Men för att rita ena Rektangeln direkt i paintComponent skriver du:
g.fillRect(r1.getXPos(),r1.getYPos(),r1.getBredd(),r1.getHöjd());

Du kan även göra som perost skrev:
Gör en egen paint-metod i Rektangel:

public void paint(Graphics g) {
     g.fillRect(xpos,ypos,bredd,höjd);
}

som du kallar från paintComponent, enligt: r1.paint(g);