PowerPoint-presentatie

Hoofdstuk 12:
Grafische mogelijkheden en
Java2D
JAVA
1
Gebruikte klassen en interfaces
Object
Color
Component
Font
FontMetrics
Graphics
Polygon
Classes and interfaces from the Java2D API that appear
in package java.awt
Graphics2D
interface
java.awt.Paint
BasicStroke
interface
java.awt.Shape
GradientPaint
interface
java.awt.Stroke
TexturePaint
Classes from the Java2D API that appear in package
java.awt.geom
GeneralPath
Line2D
RectangularShape
Arc2D
Ellipse2D
Rectangle2D
JAVA
RoundRectangle2D
2
1

Inleiding
Grafische mogelijkheden van Java




2D-vormen
Kleuren (class Color)
Lettertypen (class Font)
Java 2D API

Uitgebreide grafische mogelijkheden


Aangepaste 2D-vormen
Vormen opvullen met kleuren en patronen
JAVA
3
1

Inleiding
Coördinatenstelsel in Java




Identificeert alle punten op een scherm
Linkerbovenhoek heeft coördinaten (0,0) en bevindt
zich achter de titelbalk van het venster.
De methode getInsets() levert een Insets object af (top,
bottom, left, right: aantal pixels tussen de rand van het
venster en het tekengebied).
Elk punt bestaat uit een x-coördinaat en een ycoördinaat
De eenheid is de pixel
JAVA
4
Coördinatenstelsel in Java
(0, 0)
X-as
( x, y)
Y –as
JAVA
5
2 Grafische context en
grafische objecten

Grafische context


Maakt tekenen mogelijk op het scherm
Een graphics object beheert de grafische context


class Graphics is abstract



Controleert hoe gegevens worden getekend
Kan niet geïnstantieerd worden
Draagt bij tot de overdraagbaarheid van Java
class Component heeft een methode paint met als
argument een Graphics object



public void paint (Graphics g)
De methode paint wordt zelden aangeroepen omdat het grafisch tekenen
een event-driven proces is
De methode repaint roept de methode update aan die op haar beurt de
methode paint aanroept. Deze methode repaint mag niet overriden
worden.
JAVA
6
3

Gebruik van kleuren
class Color


Bevat methoden en constanten om kleuren te
manipuleren
Kleuren worden gecreëerd vertrekkende van
rode, groene en blauwe bestanddelen

RGB waarden:



int tussen 0 en 255
float tussen 0.0 en 1.0
Java biedt een keuze aan uit 256x256x256 (16,7 miljoen)
mogelijke kleuren
JAVA
7
Statische constanten van de class
Color
Color Constante
Kleur
RGB waarde
public final static Color orange
oranje
255, 200, 0
public final static Color pink
roze
255, 175, 175
public final static Color cyan
cyaan
0, 255, 255
public final static Color magenta
magenta
255, 0, 255
public final static Color yellow
geel
255, 255, 0
public final static Color black
zwart
0, 0, 0
public final static Color white
wit
255, 255, 255
public final static Color gray
grijs
128, 128, 128
public final static Color lightGray
Licht grijs
192, 192, 192
public final static Color darkGray
donker grijs
64, 64, 64
public final static Color red
rood
255, 0, 0
public final static Color green
groen
0, 255, 0
public final static Color blue
blauw
0, 0, 255
JAVA
8
Methoden van de class Color
Methode
Beschrijving
public Color( int r, int g, Creëert een kleur gebaseerd op rode, groene en blauwe
int b )
bestanddelen uitgedrukt als integers tussen 0 en 255.
public Color( float r,
Creëert een kleur gebaseerd op rode, groene en blauwe
float g, float b )
bestanddelen uitgedrukt als floating-point waarde tussen 0.0
en 1.0.
public int getRed()
// Color class
Levert een waarde af tussen 0 en 255 die het rode bestanddeel
voorstelt.
public int getGreen()
// Color class
Levert een waarde af tussen 0 en 255 die het groene
bestanddeel voorstelt.
public int getBlue()
// Color class
Levert een waarde af tussen 0 en 255 die het blauwe
bestanddeel voorstelt.
public Color getColor()
// Graphics class
Levert een Color object af dat de huidige kleur van de
grafische context voorstelt.
public void setColor( Color Stelt de huidige kleur in om te tekenen in de grafische context.
c ) // Graphics class
JAVA
9
Voorbeeld
Het gebruik van enkele methoden van
de class Color. Rechthoeken en tekst
worden getekend in verschillende
kleuren.
JAVA
10
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
// Fig. 12.5: ShowColors.java
// Het gebruik van kleuren
// Java core packages
import java.awt.*;
import java.awt.event.*;
// Java extension packages
import javax.swing.*;
public class ShowColors extends JFrame {
Tekent het venster
// constructor geeft een titel en afmetingen aan het venster
public ShowColors()
wanneer de uitvoering
{
van de applicatie start
super( "Using colors" );
setSize( 400, 130 );
setVisible( true );
}
Methode setColor stelt de RGB
waarde van de kleur in
// teken rechthoeken en tekst in verschillende kleuren
public void paint( Graphics g )
{
// aanroep van de methode paint van de superclass
super.paint( g );
Methode fillRect tekent een
gevulde rechthoek met gegeven
coördinaten gebruikmakende van
de huidige RGB waarde
// stel een kleur in met behulp van integers
g.setColor( new Color( 255, 0, 0 ) );
g.fillRect( 25, 25, 100, 20 );
g.drawString( "Current RGB: " + g.getColor(), 130, 40 );
// stel een kleur in met behulp van floats
g.setColor( new Color( 0.0f, 1.0f, 0.0f ) );
g.fillRect( 25, 50, 100, 20 );
Methode drawString tekent
tekst in de ingestelde kleur op de
aangegeven plaats
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
g.drawString( "Current RGB: " + g.getColor(), 130, 65 );
// stel een kleur in met behulp van de statische constanten uit de klasse Color
g.setColor( Color.blue );
g.fillRect( 25, 75, 100, 20 );
g.drawString( "Current RGB: " + g.getColor(), 130, 90 );
// toon de individuele RGB waarden
Color color = Color.magenta;
g.setColor( color );
g.fillRect( 25, 100, 100, 20 );
g.drawString( "RGB values: " + color.getRed() + ", " +
color.getGreen() + ", " + color.getBlue(), 130, 115 );
}
// voer de applicatie uit
public static void main( String args[] )
{
ShowColors application = new ShowColors();
application.setDefaultCloseOperation(
JFrame.EXIT_ON_CLOSE );
}
}
// einde class ShowColors
Gebruik constanten uit de
class Color om de huidige
kleur in te stellen
Voorbeeld
Het gebruik van JColorChooser. Wanneer de
gebruiker op de knop “Change Color” klikt,
kan hij een kleur kiezen. De achtergrond van
het venster krijgt vervolgens de gekozen
kleur.
JAVA
13
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
// Fig. 12.6: ShowColors2.java
// Het gebruik van JColorChooser
// Java core packages
import java.awt.*;
import java.awt.event.*;
// Java extension packages
import javax.swing.*;
public class ShowColors2 extends JFrame {
private JButton changeColorButton;
private Color color = Color.lightGray;
private Container container;
// aanmaak van de GUI
public ShowColors2()
{
super( "Using JColorChooser" );
container = getContentPane();
container.setLayout( new FlowLayout() );
JColorChooser laat de
gebruiker een kleur kiezen
// aanmaak van de changeColorButton en registratie van zijn event handler
changeColorButton = new JButton( "Change Color" );
changeColorButton.addActionListener(
// anonieme inner class
new ActionListener() {
// toon JColorChooser wanneer de gebruiker klikt op de knop
public void actionPerformed( ActionEvent event )
{
color = JColorChooser.showDialog(
De statische
methode showDialog
toont de “color chooser
dialog”
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
ShowColors2.this, "Choose a color", color );
// stel default kleur in, wanneer er geen kleur werd geretourneerd
if ( color == null )
color = Color.lightGray;
// wijzig de achtergrondkleur van de content pane
container.setBackground( color );
}
}
// einde van de anonieme inner class
); // einde aanroep addActionListener
container.add( changeColorButton );
setSize( 400, 130 );
setVisible( true );
}
// voer de applicatie uit
public static void main( String args[] )
{
ShowColors2 application = new ShowColors2();
application.setDefaultCloseOperation(
JFrame.EXIT_ON_CLOSE );
}
}
// einde class ShowColors2
JColorChooser dialoogbox
JAVA
17
4

Gebruik van lettertypen
class Font


Bevat methoden en constanten om lettertypen te
manipuleren
Constructor met drie argumenten

Naam


Stijl



Monospaced, SansSerif, Serif, etc.
Font.PLAIN, Font.ITALIC and Font.BOLD
De stijlen kunnen gecombineerd worden,
zoals Font.ITALIC + Font.BOLD
Grootte

Uitgedrukt in punten (1/72 inch)
JAVA
18
Methoden van de class Font
Methode of consta nte
Beschrijving
public final static int PLAIN
// Font class
Een constante die een volle stijl voorstelt.
public final static int BOLD
// Font class
Een constante die een vette stijl voorstelt.
public final static int ITALIC
// Font class
Een constante die een cursieve stijl voorstelt.
public Font( String name, int
style, int size )
Maakt een nieuw Font object met het gespecificeerde
lettertype, stijl en grootte.
public int getStyle()
// Font class
Levert een integer af die de huidige stijl van het lettertype
weergeeft.
public int getSize()
// Font class
Levert een integer af die de huidige grootte van het lettertype
weergeeft.
public String getName()
// Font class
Levert een string af die de huidige naam van het lettertype
weergeeft.
public String getFamily()
// Font class
Levert een string af die de huidige familie van het lettertype
weergeeft.
JAVA
19
Methoden van de class Font
Methode of constante
public boolean isPlain()
// Font class
Beschrijving
public boolean isBold()
// Font class
Controleert een lettertype op een vette stijl. Levert true
af bij een vet lettertype.
public boolean isItalic()
// Font class
Controleert een lettertype op een cursieve stijl. Levert
true af bij een cursief lettertype.
public Font getFont()
// Graphics class
Levert een reference naar een Font object af met het
huidige lettertype.
Controleert een lettertype op een volle stijl. Lvert true
af bij een vol lettertype.
public void setFont( Font f ) Stel het huidige lettertype in met de gegevens van de
// Graphics class
reference f naar een Font.
JAVA
20
Voorbeeld
Gebruik van lettertypen. Er
worden vier lettertypen gebruikt,
elk in een andere grootte.
JAVA
21
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
// Fig. 12.9: Fonts.java
// Gebruik van lettertypen
// Java core packages
import java.awt.*;
// Java extension packages
import javax.swing.*;
public class Fonts extends JFrame {
// instellen van de titel en afmetingen van het venster
public Fonts()
{
super( "Using fonts" );
setSize( 420, 125 );
setVisible( true );
}
// druk Strings af in verschillende lettertypen en kleuren
public void paint( Graphics g )
{
Methode
// aanroep van de methode paint van de superclass
super.paint( g );
setFont stelt het huidige
lettertype in
// stel het huidige lettertype in op Serif (Times), vet, 12pt
// en teken een string
g.setFont( new Font( "Serif", Font.BOLD, 12 ) );
Methode
g.drawString( "Serif 12 point bold.", 20, 50 );
// stel het huidige lettertype in op Monospaced (Courier),
// cursief, 24pt en teken een string
g.setFont( new Font( "Monospaced", Font.ITALIC, 24 ) );
drawString gebruikt
het huidige lettertype
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
g.drawString( "Monospaced 24 point italic.", 20, 70 );
// stel het huidige lettertype in op SansSerif (Helvetica),
// vol, 14pt en teken een string
g.setFont( new Font( "SansSerif", Font.PLAIN, 14 ) );
g.drawString( "SansSerif 14 point plain.", 20, 90 );
// stel het huidige lettertype in op Serif (times), vet, cursief,
// 18pt en teken een string
g.setColor( Color.red );
Stel lettertype in: SansSerif,14-pt,vol
g.setFont(
new Font( "Serif", Font.BOLD + Font.ITALIC, 18 ) );
g.drawString( g.getFont().getName() + " " +
g.getFont().getSize() +
" point bold italic.", 20, 110 );
Stel lettertype in: Serif, 18-pt, vet,
cursief
}
// voer de applicatie uit
public static void main( String args[] )
{
Fonts application = new Fonts();
application.setDefaultCloseOperation(
JFrame.EXIT_ON_CLOSE );
}
}
// einde class Fonts
Gebruik van lettertypen

Font metrics
Xy1Õ
height




leading
ascent
baseline
descent
Height
Descent (amount character dips below baseline)
Ascent (amount character rises above baseline)
Leading (difference between descent of one line of text and ascent
of the line of text below it)
JAVA
24
Methoden mbt font metrics
Methode
Beschrijving
public int getAscent()
// FontMetrics class
Levert een waarde af die de ascent van een lettertype voorstelt in
punten.
public int getDescent()
// FontMetrics class
Levert een waarde af die de descent van een lettertype voorstelt in
punten.
public int getLeading()
// FontMetrics class
Levert een waarde af die de leading van een lettertype voorstelt in
punten.
public int getHeight()
// FontMetrics class
Levert een waarde af die de height van een lettertype voorstelt in
punten.
public FontMetrics
getFontMetrics()
// Graphics class
Levert een FontMetrics object af voor het huidige Font.
public FontMetrics
getFontMetrics( Font f )
// Graphics class
Levert een FontMetrics object af voor het gespecificeerde Font
argument.
JAVA
25
Voorbeeld
Gebruik van font metrics voor
twee lettertypen.
JAVA
26
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
// Fig. 12.12: Metrics.java
// Gebruik van methoden van de klasse FontMetrics en
// de klasse Graphics met betrekking tot font metrics
// Java core packages
import java.awt.*;
// Java extension packages
import javax.swing.*;
public class Metrics extends JFrame {
// instellen van de titel en de afmetingen van het venster
public Metrics()
{
super( "Demonstrating FontMetrics" );
setSize( 510, 210 );
setVisible( true );
}
-
// toon font metrics
Instellen
public void paint( Graphics g )
{
// aanroep van de methode paint van de superclass
super.paint( g );
lettertype: SansSerif, 12-pt, vet
g.setFont( new Font( "SansSerif", Font.BOLD, 12 ) );
FontMetrics metrics = g.getFontMetrics();
g.drawString( "Current font: " + g.getFont(), 10, 40 );
g.drawString( "Ascent: " + metrics.getAscent(), 10, 55 );
g.drawString( "Descent: " + metrics.getDescent(), 10, 70 );
g.drawString( "Height: " + metrics.getHeight(), 10, 85 );
g.drawString( "Leading: " + metrics.getLeading(), 10, 100);
FontMetrics object
voor het huidige
lettertype
Gebruik
FontMetrics voor
ascent, descent, height
en leading
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
Font font = new Font( "Serif", Font.ITALIC, 14 );
metrics = g.getFontMetrics( font );
g.setFont( font );
g.drawString( "Current font: " + font, 10, 130 );
g.drawString( "Ascent: " + metrics.getAscent(), 10, 145 );
g.drawString( "Descent: " + metrics.getDescent(), 10, 160);
g.drawString( "Height: " + metrics.getHeight(), 10, 175 );
g.drawString( "Leading: " + metrics.getLeading(), 10, 190);
}
// voer de applicatie uit
public static void main( String args[] )
{
Metrics application = new Metrics();
application.setDefaultCloseOperation(
JFrame.EXIT_ON_CLOSE );
}
}
// einde class Metrics
Herhaal hetzelfde voor
het lettertype Serif, 14-pt,
cursief
5 Lijnen, rechthoeken en
ellipsen tekenen

class Graphics

Voorziet methoden om lijnen, rechthoeken
en ellipsen te tekenen

Alle methoden hebben argumenten width and
height (positieve gehele getallen)
JAVA
29
Methoden van Graphics
Methode
Beschrijving
public void drawLine( int x1, int y1, int x2, int y2 )
Tekent een lijn tuusen het punt (x1, y1) en het punt (x2, y2).
public void drawRect( int x, int y, int width, int height )
Tekent een rechthoek met gegeven breedte en hoogte. De linkerbovenhoek van de
rechthoek heeft coördinaten (x, y).
public void fillRect( int x, int y, int width, int height )
Tekent een gevulde rechthoek met gegeven breedte en hoogte. De linkerbovenhoek
van de rechthoek heeft coördinaten (x, y).
public void clearRect( int x, int y, int width, int height )
Tekent een gevulde rechthoek met gegeven breedte en hoogte in de huidige
achtergrondkleur. De linkerbovenhoek van de rechthoek heeft coördinaten (x, y).
public void drawRoundRect( int x, int y, int width, int height, Tekent een rechthoek met afgeronde hoeken in de huidige kleur met gegeven
breedte en hoogte. De arcWidth en arcHeight bepaalt de kromming van de
int arcWidth, int arcHeight )
hoeken.
public void fillRoundRect( int x, int y, int width, int height,
int arcWidth, int arcHeight )
Tekent een gevulde rechthoek met afgeronde hoeken in de huidige kleur met
gegeven breedte en hoogte. De arcWidth en arcHeight bepaalt de kromming van
de hoeken.
JAVA
30
Methoden van Graphics
Methode
Beschrijving
public void fill3DRect(
int x, int y, int width,
int height, boolean b )
Tekent een gevulde driedimensionale rechthoek in de huidige kleur
met gegeven breedte en hoogte. De linkerbovenhoek van de rechthoek
heeft als coördinaten (x, y). De rechthoek wordt verheven
weergegeven als b true is en ingedrukt weergegeven als b false is.
public void drawOval( int
x, int y, int width, int
height )
Tekent een ellips in de huidge kleur met gegeven breedte en hoogte.
De linkerbovenhoek van de omschreven rechthoek heeft coördinaten
(x, y). De ellips raakt de omschreven rechthoek in het midden van
elke zijde.
public void fillOval( int
x, int y, int width, int
height )
Tekent een gevulde ellips in de huidge kleur met gegeven breedte en
hoogte. De linkerbovenhoek van de omschreven rechthoek heeft
coördinaten (x, y). De ellips raakt de omschreven rechthoek in het
midden van elke zijde.
JAVA
31
Voorbeeld
Lijnen, rechthoeken en ellipsen
tekenen.
JAVA
32
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
// Fig. 12.14: LinesRectsOvals.java
// Lijnen, rechthoeken en ellipsen tekenen
// Java core packages
import java.awt.*;
// Java extension packages
import javax.swing.*;
public class LinesRectsOvals extends JFrame {
// instellen van de titel en de afmetingen van het venster
public LinesRectsOvals()
{
super( "Drawing lines, rectangles and ovals" );
setSize( 400, 165 );
setVisible( true );
}
// tekenen van lijnen, rechthoeken en ellipsen
public void paint( Graphics g )
{
// aanroep van de methode paint van de superclass
super.paint( g );
g.setColor( Color.red );
g.drawLine( 5, 30, 350, 30 );
g.setColor( Color.blue );
g.drawRect( 5, 40, 90, 55 );
g.fillRect( 100, 40, 90, 55 );
g.setColor( Color.cyan );
Teken een gevulde afgeronde rechthoek
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
g.fillRoundRect( 195, 40, 90, 55, 50, 50 );
g.drawRoundRect( 290, 40, 90, 55, 20, 20 );
Teken een afgeronde rechthoek
g.setColor( Color.yellow );
g.draw3DRect( 5, 100, 90, 55, true );
g.fill3DRect( 100, 100, 90, 55, false );
Teken een 3D rechthoek
Teken een gevulde 3D rechthoek
g.setColor( Color.magenta );
g.drawOval( 195, 100, 90, 55 );
g.fillOval( 290, 100, 90, 55 );
Teken een ellips
}
// voer de applicatie uit
Public static void main( String args[] )
{
LinesRectsOvals application = new LinesRectsOvals();
application.setDefaultCloseOperation(
JFrame.EXIT_ON_CLOSE );
}
}
// einde class LinesRectsOvals
Teken een gevulde ellips
De breedte en de hoogte van een boog
voor rechthoeken met afgeronde hoeken
(x, y)
arc height
arc width
height
•Gelijke waarden voor
arc height en arc width
resulteert in een vierde
van een cirkel in elke
hoek van de rechthoek
•Gelijke waarden voor
width, height, arc
height en arc width
resulteert in een cirkel.
width
JAVA
35
Een ellips in een omschreven
rechthoek
( x, y)
height
width
De ellips raakt het midden van elke zijde van de omschreven rechthoek.
JAVA
36
6 Bogen tekenen

Boog (arc)




Is een deel van een ellips
Wordt uitgedrukt in graden
tekent het aantal graden van de boog op een
ellips in een omschreven rechthoek
het tekenen begint bij de starthoek


In tegenwijzerszin tekenen wordt uitgedrukt met een
positief aantal graden
In wijzerszin tekenen wordt uitgedrukt met een negatief
aantal graden
JAVA
37
Positieve en negatieve
hoeken bij bogen
Positieve hoeken
90°
180°
0°
Negatieve hoeken
90°
180°
270°
0°
270°
JAVA
38
Graphics methoden om
bogen te tekenen
Methode
Beschrijving
public void drawArc( int x, int y,
int width, int height,
int startAngle, int arcAngle )
Tekent een boog relatief ten opzichte van de omschreven rechthoek met
(x,y) de coördinaten van de linkerbovenhoek en de gespecificeerde
breedte en hoogte.
De boog wordt getekend vanaf de starthoek en draait over een gegeven
aantal graden.
public void fillArc( int x, int y,
int width, int height, int
startAngle, int arcAngle )
Tekent een gevulde boog (een sector) relatief ten opzichte van de
omschreven rechthoek met (x,y) de coördinaten van de linkerbovenhoek
en de gespecificeerde breedte en hoogte.
De boog wordt getekend vanaf de starthoek en draait over een gegeven
aantal graden.
JAVA
39
Voorbeeld
Bogen tekenen.
JAVA
40
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
// Fig. 12.19: DrawArcs.java
// Bogen tekenen
// Java core packages
import java.awt.*;
// Java extension packages
import javax.swing.*;
public class DrawArcs extends JFrame {
// instellen van een titel en de afmetingen van het venster
public DrawArcs()
{
super( "Drawing Arcs" );
setSize( 300, 170 );
setVisible( true );
}
// rechthoeken en bogen tekenen
public void paint( Graphics g )
{
// aanroep van de methode paint
super.paint( g );
van de superclass
// begin bij 0 en teken 360 graden
g.setColor( Color.yellow );
g.drawRect( 15, 35, 80, 80 );
g.setColor( Color.black );
g.drawArc( 15, 35, 80, 80, 0, 360 );
// begin bij 0 en teken 110 graden
g.setColor( Color.yellow );
Teken een boog van 360
graden in een gegeven
omschreven rechthoek
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
g.drawRect( 100, 35, 80, 80 );
g.setColor( Color.black );
g.drawArc( 100, 35, 80, 80, 0, 110 );
// begin bij 0 en teken -270 graden
g.setColor( Color.yellow );
g.drawRect( 185, 35, 80, 80 );
g.setColor( Color.black );
g.drawArc( 185, 35, 80, 80, 0, -270 );
// begin bij 0 en teken 360 graden
g.fillArc( 15, 120, 80, 40, 0, 360 );
// begin bij 270 en teken -90 graden
g.fillArc( 100, 120, 80, 40, 270, -90 );
// begin bij 0 en teken -270 graden
g.fillArc( 185, 120, 80, 40, 0, -270 );
}
// voer de applicatie uit
public static void main( String args[] )
{
DrawArcs application = new DrawArcs();
application.setDefaultCloseOperation(
JFrame.EXIT_ON_CLOSE );
}
}
// einde van de class DrawArcs
Teken een boog van 110
graden in een
omschreven rechthoek
Teken een boog van –270
graden in een omschreven
rechthoek
Teken een gevulde boog met starthoek 0
en draai 360 graden
Teken een gevulde boog met starthoek
270 en draai -90 graden
Teken een gevulde boog met starthoek 0
en draai -270 graden
7 Polygonen en polylijnen

class Polygon

Polygoon


Gesloten vorm met vele rechte zijden
Polylijn

Verzameling van verbonden punten
JAVA
44
Methoden voor polygonen en
polylijnen
Methode
Omschrijving
public void drawPolygon( int xPoints[], Tekent een polygoon. De x-coördinaat van elk punt is gespecificeerd in de
int yPoints[],int points )
xPoints array en de y-coördinaat van elk punt is gespecificeerd in de
yPoints array. Het laatste argument geeft het aantal punten. Deze methode
tekent een gesloten polygoon, zelfs al is het laatste punt verschillend van het
eerste punt.
public void drawPolyline(
Tekent een verzameling van verbonden lijnen. De x-coördinaat van elk punt is
int xPoints[], int yPoints[],
gespecificeerd in de xPoints array en de y-coördinaat van elk punt is
int points )
gespecificeerd in de yPoints array. Het laatste argument geeft het aantal
punten. Is het laatste punt verschillend van het eerste punt, dan is de polylijn niet
gesloten.
public void drawPolygon( Polygon p )
Tekent de gespecificeerde gesloten polygoon.
public void fillPolygon( int xPoints[], Tekent een gevulde polygoon. De x-coördinaat van elk punt is gespecificeerd in
int yPoints[], int points )
de xPoints array en de y-coördinaat van elk punt is gespecificeerd in de
yPoints array. Het laatste argument geeft het aantal punten. Deze methode
tekent een gesloten polygoon, zelfs al is het laatste punt verschillend van het
eerste punt.
public void fillPolygon( Polygon p )
Tekent de gespecificeerde gevulde polygoon. De polygoon is gesloten.
public Polygon()
// Polygon class
public Polygon( int xValues[],
int yValues[], int numberOfPoints )
// Polygon class
Creëert een nieuw polygoon object. De polygoon bevat geen enkel punt.
public void addPoint(int x, int y )
JAVA
Voegt een
paar (x,y) toe aan de polygoon
Creëert een nieuw polygoon object. De polygoon heeft numberOfPoints
zijden, waarvan elk punt bestaat uit een x-coördinaat uit xValues en een ycoördinaat uit yValues.
45
Voorbeeld
Polygonen en polylijnen tekenen.
JAVA
46
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
// Fig. 12.21: DrawPolygons.java
// Polygonen tekenen
// Java core packages
import java.awt.*;
// Java extension packages
import javax.swing.*;
public class DrawPolygons extends JFrame {
// instellen van de titel en de afmetingen van het venster
public DrawPolygons()
{
super( "Drawing Polygons" );
setSize( 275, 230 );
setVisible( true );
}
// polygonen en polylijnen tekenen
public void paint( Graphics g )
{
// aanroepen van de methode paint van de superclass
super.paint( g );
int xValues[] = { 20, 40, 50, 30, 20, 15 };
int yValues[] = { 50, 50, 60, 80, 80, 60 };
Polygon polygon1 = new Polygon( xValues, yValues, 6 );
int arrays met de punten van
de Polygon polygon1
Teken polygon1 op het
scherm
g.drawPolygon( polygon1 );
int xValues2[] = { 70, 90, 100, 80, 70, 65, 60 };
int yValues2[] = { 100, 100, 110, 110, 130, 110, 90 };
int arrays met de punten van
de Polygon polygon2
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
Teken polygon2 op het
scherm
g.drawPolyline( xValues2, yValues2, 7 );
int xValues3[] = { 120, 140, 150, 190 };
int yValues3[] = { 40, 70, 80, 60 };
Specificeer de punten van de
Polygon polygon3 en teken een
gevulde polygoon op het scherm
g.fillPolygon( xValues3, yValues3, 4 );
Polygon polygon2 =
polygon2.addPoint(
polygon2.addPoint(
polygon2.addPoint(
polygon2.addPoint(
polygon2.addPoint(
new Polygon();
165, 135 );
175, 150 );
270, 200 );
200, 220 );
130, 180 );
g.fillPolygon( polygon2 );
De methode addPoint voegt punten met x en
y coördinaten toe aan Polygon
}
// voer de applicatie uit
public static void main( String args[] )
{
DrawPolygons application = new DrawPolygons();
application.setDefaultCloseOperation(
JFrame.EXIT_ON_CLOSE );
}
}
// einde van de class DrawPolygons
Resultaat van lijn 42
Resultaat van lijn 32
DrawPolygons.java
Output
Resultaat van lijn 37
Resultaat van lijn 51
8 Java 2D API

Java 2D API

Uitgebreide 2D grafische mogelijkheden







java.awt
java.awt.image
java.awt.color
java.awt.font.geom
java.awt.print
java.awt.image.renderable
Gebruikt de class java.awt.Graphics2D

extends class java.awt.Graphics
JAVA
50
Java 2D vormen

Package java.awt.geom





Ellipse2D.Double
Rectangle2D.Double
RoundRectangle2D.Double
Arc3D.Double
Lines2D.Double
JAVA
51
Voorbeeld
Enkele Java2D vormen en hun
specifieke eigenschappen.
JAVA
52
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
// Fig. 12.22: Shapes.java
// Enkele Java2D vormen
// Java core packages
import java.awt.*;
import java.awt.geom.*;
import java.awt.image.*;
// Java extension packages
import javax.swing.*;
public class Shapes extends JFrame {
// instellen van de titel en de afmetingen van het venster
public Shapes()
{
super( "Drawing 2D shapes" );
setSize( 425, 160 );
setVisible( true );
}
// teken vormen met Java2D API
public void paint( Graphics g )
{
// aanroep van de methode paint van de superclass
super.paint( g );
// maak 2D door typeconversie van g naar Graphics2D
Graphics2D g2d = ( Graphics2D ) g;
// teken 2D ellips gevuld met een blauw-gele gradiënt
g2d.setPaint( new GradientPaint( 5, 30, Color.blue, 35,
100, Color.yellow, true ) );
Gebruik GradientPaint
om de vorm te vullen met
een gradiënt
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
g2d.fill( new Ellipse2D.Double( 5, 30, 65, 100 ) );
Vul de ellips met de gradiënt
// teken een rode 2D rechthoek
g2d.setPaint( Color.red );
g2d.setStroke( new BasicStroke( 10.0f ) );
g2d.draw( new Rectangle2D.Double( 80, 30, 65, 100 ) );
Gebruik BasicStroke om
een 2D rechthoek te tekenen
met een rode rand
// teken een afgeronde 2D rechthoek met een gebufferde achtergrond
BufferedImage buffImage = new BufferedImage(
BufferedImage
10, 10, BufferedImage.TYPE_INT_RGB );
Graphics2D gg = buffImage.createGraphics();
gg.setColor( Color.yellow ); // teken met geel
gg.fillRect( 0, 0, 10, 10 ); // teken een gevulde rechthoek
gg.setColor( Color.black ); // teken met zwart
gg.drawRect( 1, 1, 6, 6 );
// teken een rechthoek
gg.setColor( Color.blue );
// teken met blauw
gg.fillRect( 1, 1, 3, 3 );
// teken een gevulde rechthoek
gg.setColor( Color.red );
// teken met rood
gg.fillRect( 4, 4, 3, 3 );
// teken een gevulde rechthoek
// teken buffImage in JFrame
g2d.setPaint( new TexturePaint(
buffImage, new Rectangle( 10, 10 ) ) );
g2d.fill( new RoundRectangle2D.Double(
155, 30, 75, 100, 50, 50 ) );
// teken een 2D boog met wit
g2d.setPaint( Color.white );
g2d.setStroke( new BasicStroke( 6.0f ) );
g2d.draw( new Arc2D.Double(
240, 30, 75, 100, 0, 270, Arc2D.PIE ) );
// teken 2D lijnen met groen en geel
g2d.setPaint( Color.green );
levert een beeld dat kan
bewerkt worden
Vul
BufferedImage
op
Gebruik BufferedImage als
vulling bij het tekenen van een
afgeronde rechthoek
Gebruik
Arc2D.PIE om
een 2D boog te
tekenen met een
witte rand
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
g2d.draw( new Line2D.Double( 395, 30, 320, 150 ) );
float dashes[] = { 10 };
g2d.setPaint( Color.yellow );
g2d.setStroke( new BasicStroke( 4, BasicStroke.CAP_ROUND,
BasicStroke.JOIN_ROUND, 10, dashes, 0 ) );
g2d.draw( new Line2D.Double( 320, 30, 395, 150 ) );
}
// voer de applicatie uit
public static void main( String args[] )
{
Shapes application = new Shapes();
application.setDefaultCloseOperation(
JFrame.EXIT_ON_CLOSE );
}
}
// einde van de class Shapes
Teken een volle
groene lijn
Teken een gebroken gele
lijn die de volle groene lijn
snijdt
Voorbeeld
Tekenen van vormen opgebouwd uit
rechte lijnen en complexe curven.
JAVA
56
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
// Fig. 12.23: Shapes2.java
// Demonstratie
// Java core packages
import java.awt.*;
import java.awt.geom.*;
// Java extension packages
import javax.swing.*;
public class Shapes2 extends JFrame {
// instellen van de titel, de afmetingen en de achtergrondkleur
// van het venster
public Shapes2()
{
super( "Drawing 2D Shapes" );
getContentPane().setBackground( Color.yellow );
setSize( 400, 400 );
setVisible( true );
}
public void paint( Graphics g )
{
// aanroep van de methode paint van de superclass
super.paint( g );
int xPoints[] =
{ 55, 67, 109, 73, 83, 55, 27, 37, 1, 43 };
int yPoints[] =
{ 0, 36, 36, 54, 96, 72, 96, 54, 36, 36 };
x-y coördinaten voor de sterren
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
Graphics2D g2d = ( Graphics2D ) g;
// maak een ster met een reeks punten
GeneralPath star = new GeneralPath();
// stel de eerste coordinaat in van General Path
star.moveTo( xPoints[ 0 ], yPoints[ 0 ] );
GeneralPath is een
vorm opgebouwd uit
rechte lijnen en complexe
curven
// creëer een ster - er wordt hier geen ster getekend
for ( int count = 1; count < xPoints.length; count++ )
star.lineTo( xPoints[ count ], yPoints[ count ] );
Maak een
ster
// sluit de vorm
star.closePath();
// verschuif de oorsprong naar (200, 200)
g2d.translate( 200, 200 );
// draai rond de oorsprong en teken sterren met willekeurige kleuren
for ( int count = 1; count <= 20; count++ ) {
// draai het coördinatenstelsel
g2d.rotate( Math.PI / 10.0 );
// instellen van de willekeurige
g2d.setColor( new Color(
( int ) ( Math.random() * 256
( int ) ( Math.random() * 256
( int ) ( Math.random() * 256
// teken een gevulde ster
g2d.fill( star );
}
}
// einde method paint
kleur om te tekenen
),
),
) ) );
Teken 20 sterren
rond de oorsprong,
gevuld met een
willekeurige kleur
71
72
73
74
75
76
77
78
79
80
81
// voer de applicatie uit
public static void main( String args[] )
{
Shapes2 application = new Shapes2();
application.setDefaultCloseOperation(
JFrame.EXIT_ON_CLOSE );
}
}
// einde van de class Shapes2
Oefeningen
Hoofdstuk 12
JAVA
60
Oefening 1

Teken acht concentrische cirkels. De
afstand tussen de cirkels bedraagt 10
pixels.
JAVA
61
Oefening 2

Teken lijnen van random lengte en in
random kleuren.
JAVA
62
Oefening 3

Schrijf een applicatie die tien random
driehoeken tekent in verschillende
kleuren. Elke driehoek wordt gevuld
met een andere kleur. Gebruik de class
GeneralPath en de methode fill van de
class Graphics2D om deze driehoeken
te tekenen.
JAVA
63
Oefening 4

Teken een piramide. Maak gebruik van
de class GeneralPath en de methode
draw uit de class Graphics2D.
JAVA
64