java graphics

[websitevrager]

Hallo,

Als je een simpel spel maakt in java, en je gebruikt dus bijvoorbeeld cirkels, rechthoeken en afbeeldingen als graphics, dan moet je dus ergens een klasse met de method paintComponent() maken om de graphics te laten zien.
Je doet dan bijvoorbeeld een JPanel gebruiken als vel papier en de method paintComponent() gebruik je dan om met de Graphics2D class de vormen en afbeeldingen te laten zien.
Maar als je alle graphics steeds alleen kunt maken in de method paintComponent(), dan wordt die method wel heel erg groot.
Ik denk daarom dat ik iets verkeerd doe.
Is er niet een manier om bijvoorbeeld een klasse "Beeldscherm" te maken en dan die klasse een public variabele geven die een Graphics2D instantie is.
Als je dan een rechthoek wilt tekenen doe je dit:

Rectangle2D = new Rectangle2D.Double(100, 50, 10, 10);
Beeldscherm.g2.fill(rect);

// Beeldscherm.g2 is een Graphics2D object
Kan iemand me wat meer uitleggen hierover?

 

[frankwannet]

@AjaxKing97: Jouw reactie verwijderd. De topicstarter vraagt om uitleg over programmeren in Java. Jouw reactie voegt niets toe aan hetgeen de topicstarter naar vraagt.

 

[kenikavanbis]

bekijk volgende link http://code.google.com/p/javamygame/source/browse/trunk/Java_Gamer/src/be/djdb/game/Playground.java
en merk op dat de paint en repaint is geimplementeert en hier begint een magie

 

[NewbiProgrammer]

Als je Object georiënteerd programmeert, zal je opmerken dat je niet heel grootte klassen zult krijgen. Je hebt namelijk verschillende klassen. Deze klassen kan je allemaal hun eigen dingen laten tekenen zodat jouw teken methodes niet zo groot worden.


Als voorbeeld schets ik een huis.

public class Huis implements Tekenbaar {

   private Deur deur;

   public Huis() {
        deur = new Deur();
    }


    ....

    @Override 
    public void teken(Graphics2D g2) {
         //de dingen die ik voor het huis moet tekenen.
         g2.drawRectangle(...);
         //en de deur mag zich gaan tekenen.
         deur.teken(g2);
    }
}

public class Deur implements Tekenbaar {

   private Handvat handvat;

   public Deur () {
        handvat = new Handvat ();
   }

    ....

    @Override 
    public void teken(Graphics2D g2) {
         //de dingen die ik voor de deur moet tekenen.
         g2.drawRectangle(...);
         //en  het handvat mag zich gaan tekenen.
         handvat.teken(g2);
    }
}

Daarnaast heb je natuurlijk ook zaken die niks met het huis te maken hebben. Bijvoorbeeld een tuin. Dit gaat op dezelfde manier.

public class Tuin implements Tekenbaar {

   public Tuin () {
        
   }

    ....

    @Override 
    public void teken(Graphics2D g2) {
         //de dingen die ik voor de tuin moet tekenen.
         g2.drawRectangle(...);
         ...
    }
}

Omdat alle objecten de interface Tekenbaar implementeren is het nu heel makkelijk om alle objecten te laten tekenen.

Oh voor ik het vergeet de interface natuurlijk:

public interface Tekenbaar {
      public void teken(Graphics2D g2);
}

Dan nu de aanroep.

public class TekenPaneel {
     private List<Tekenbaar> objecten;

     public TekenPaneel() {
          objecten = new ArrayList<Tekenbaar>();
          objecten.add(new Huis());
          objecten.add(new Tuin());
     }

     public void vulTekenbareObjecten() {
          Graphics2D g2 = ... 
          objecten.teken(g2);
    }
}

Dit is natuurlijk maar een simplistisch voorbeeld. Ik ben zelf altijd fan van het visitor pattern, maar ik denk dat dat pattern een beetje lastig is als beginner. Het is ook zeker niet nodig bij een klein aantal objecten. Ga je 2d/3d games programmeren met veel objecten, dan raad ik dat pattern aan.
http://en.wikipedia.org/wiki/Visitor_pattern

Met vriendelijke groet,
NewbiProgrammer