Java Graphics
Swing Graphics
Java 2D API
Java contains sophisticated drawing capabilities
 Java 2D API
successor technology JavaFX
Java 2D capabilities
controlling the style of lines used to draw shapes
filling the shapes with colors and patterns.
The classes that are part of Java’s original
graphics capabilities are considered to be part
of the Java 2D API.
Java 2D API
 Class Color contains methods and constants for manipulating colors.
 Class JComponent contains method paintComponent, which is used
to draw graphics on a component.
 Class Font contains methods and constants for manipulating fonts.
 Class FontMetrics contains methods for obtaining font information.
 Class Graphics contains methods for drawing strings, lines, rectangles
and other shapes.
 Class Graphics2D, which extends class Graphics, is used for drawing
with the Java 2D API.
 Class Polygon contains methods for creating polygons.
 Class BasicStroke helps specify the drawing characteristics of lines.
 Classes GradientPaint and TexturePaint help specify the
characteristics for filling shapes with colors or patterns.
 Classes GeneralPath, Line2D, Arc2D, Ellipse2D, Rectangle2D and
RoundRectangle2D represent several Java 2D shapes.
 We begin drawing in Java understanding Java’s coordinate system
 By default, the upper-left corner of a GUI component (e.g., a
window) has the coordinates (0, 0).
 The x-coordinate is the horizontal distance moving right from the
left edge of the screen.
 The y-coordinate is the vertical distance moving down from the
top of the screen.
 The coordinates are used to indicate where graphics should be
displayed on a screen.
 Coordinate units are measured in pixels (which stands for “picture
elements”). A pixel is a display monitor’s smallest unit of
resolution.
Graphics Contexts and Graphics
Objects
A graphics context enables drawing on the
screen.
 A Graphics object manages a graphics context
and draws pixels on the screen that represent
text and other graphical objects (e.g., lines,
ellipses, rectangles and other polygons).
Graphics objects contain methods for drawing,
font manipulation, color manipulation and the
like
The class Graphics
 Class Graphics is an abstract class (i.e., you cannot
instantiate Graphics objects).
 This contributes to Java’s portability.
 Because drawing is performed differently on every
platform that supports Java, there cannot be only one
implementation of the drawing capabilities across all
systems.
 When Java is implemented on a particular platform, a
subclass of Graphics is created that implements the
drawing capabilities
 This implementation is hidden by class Graphics, which
supplies the interface that enables us to use graphics in
a platform-independent manner.
Swing Graphics
Empty Swing containers have no visual
appearance except for a background color
Every JComponent must have a paintComponent
method that is called when the component is first
made visible or needs to be redrawn for some
reason
The JPanel component is a lightweight container,
making it suitable as a drawing area (general
purpose container)
A common way to do graphics is to extend the
JPanel class and override the paintComponent
method
JPanel
JPanel actually serves as a general purpose container.
You can put many operations inside one panel.
JPanel is a subclass of JComponent, and JComponent is a
subclass of Container, therefore, JPanel is also a
container.
There are so many methods that can be used for JPanel,
which it inherited from its super classes.
In JPanel, you can also put fields, labels, buttons, check
boxes, and even images, and many other functions.
It simply represents an area where you can put visuals
and controls.
The differences between
Jpanel and Jframe
 In order to create a panel, you need to invoke a
constructor JPanel()
 It is opaque by default, but you can change its
background color.
 You can also customize its components using the Layout
Managers.
 The Layout Managers such as Flow Layout, Grid Layout,
Border Layout, etc., helps to control the sizes, positions,
and alignment of your components in JPanel.
 Component colors can also be customized using
setColor(color_obj), setForeGround(color_obj), and
setBackgroundColor(color_obj) constructors.
The differences between
JPanel and JFrame
 JFrame, just like JPanel, is a subclass of JComponent and
JContainer.
 It is a window with characteristics of its own.
 It has a border, title bar, and button components. Its
physical attributes, like size, color, fonts, etc., can all be
customized.
 There are proper syntax’s derived for each attribute you
want to change.
 JFrame has basically two sub-areas, the content pane
and the menu bar, but most of the controls are found in
the content pane area.
 In JFrame, you can also put buttons, labels, and check
boxes
The differences between
JPanel and JFrame
JFrame is a window commonly used for stand-alone
applications, like a warning window, or a notification
window, that you would usually see pop out on your
screen.
 It uses a method of windows listener that executes
whenever you close, open, maximize, minimize or
activate a window.
There’s also a mouse listener method that is used to
make your frame react to mouse actions.
 Frames can also have inner frames, but they are
totally dependent on the main frame.
 There are so many actions we can make for frame,
using the listeners, using the add, get, and set methods.
Class JComponent
Class Component is the superclass for many of
the classes in package java.awt.
Class JComponent (package javax.swing), which
inherits indirectly from class Component,
Class JComponent contains a paintComponent
method that can be used to draw graphics.
Method paintComponent takes a Graphics object
as an argument.
This object is passed to the paintComponent method
by the system when a lightweight Swing component
needs to be repainted.
The header for the paintComponent method is
public void paintComponent(Graphics g)
Graphics vs. Graphics2D
The Graphics class has limitations:
Cannot use real number coordinates
Cannot draw dotted, dashed, or variable-width lines
Cannot easily draw complex curves or fill complex
shapes
Cannot use textures or gradient colors to fill shapes
The newer Graphics2D class extends Graphics
and provides these capabilities
All GUI components use a Graphics2D object but
paintComponent passes a Graphics object for
backward compatibility
General Approach
public class MyPanel extends JPanel {
// instance variables
public MyPanel() {
// public constructor
}
// public methods
// private helper methods
public void paintComponent(Graphics g) {
super.paintComponent(g);
Graphics2D g2d = (Graphics2D)g;
// drawing messages sent to g2d
...
}
}
Parameter g receives a reference to an instance
of the system-specific subclass of Graphics.
class JComponent is a superclass of JPanel.
Many capabilities of class JPanel are inherited
from class JComponent.
We seldom call method paintComponent
directly, because drawing graphics is an eventdriven process.
The paintComponent Method
super.paintComponent(g) is called first to
ensure that painting responsibilities defined in
JPanel are carried out
You should not call paintComponent directly;
it is called by the JVM when it needs to
You can indirectly call paintComponent on a
component by using component.repaint()
 Java uses a multithreaded model of program execution.
 Each thread is a parallel activity.
 Each program can have many threads.
 When you create a GUI-based application, one of those
threads is known as the event-dispatch thread (EDT)—it’s
used to process all GUI events.
 All manipulation of the onscreen GUI components must
be performed in that thread.
 When a GUI application executes, the application
container calls method paintComponent (in the eventdispatch thread) for each lightweight component as the
GUI is displayed
 For paintComponent to be called again, an event must
occur (such as covering and uncovering the component
with another window).
Some Basic Graphics Methods
void setColor(Color color)
void setFont(Font font)
void drawString(String text, int x, int y)
(x,y)is the coordinate of the lower left corner of
the drawn string's leftmost character
Example
import javax.swing.*;
import java.awt.*;
public class GraphicsPanel extends JPanel {
public GraphicsPanel()
{
setPreferredSize(new Dimension(200,200));
setBackground(Color.magenta); // panel color }
public void paintComponent(Graphics g) {
super.paintComponent(g);
Graphics2D g2D = (Graphics2D)g;
g2D.setColor(Color.blue); // drawing color
g2D.setFont(new Font("Helvetica", Font.BOLD, 24));
g2D.drawString("Hello World", 25, 25);
}
}
import javax.swing.*;
import java.awt.*;
Example cont’nd
import java.awt.event.*;
public class MainFrame extends JFrame {
public MainFrame() {
setSize(new Dimension(500,300));
setLocation(100,100);
addWindowListener( new WindowAdapter () {
public void windowClosing(WindowEvent e)
{ dispose();
System.exit(0);
}
} ) ;
getContentPane().setLayout( new FlowLayout(FlowLayout.CENTER));
GraphicsPanel gp = new GraphicsPanel();
getContentPane().add(gp);
setVisible(true);
}
public static void main(String[] args) { new MainFrame();
}
}
Explanation the Example
GraphicsPanel extends JPanel so that the
paintComponent method can be overridden
If you forget to call super's paintComponent
method, you can get pixels from another
desktop frame as background garbage
The background color is associated with the
panel; the paint color with the Graphics2D
object
The MainFrame class extends JFrame and an
instance of it is created in the main method
Drawing Shapes
You can draw any object that implements the
java.awt.Shape interface.
Example: suppose g2D is a Graphics2D object:
Shape s = ...;
g2D.draw(s);
The Java library supplies a number of classes
that implement the Shape interface type.
Line Shapes
java.awt.geom.Line2D is an abstract class with
two concrete subclasses that are also inner
classes:
Line2D.Double
Line2D.Float
A Line2D object represents a line segment in (x,y)
coordinate space.
To create a line segment, first create its endpoints
using the java.awt.geom.Point2D class
import java.awt.geom.*;
...
public void paintComponent(Graphics g) {
super.paintComponent(g);
Graphics2D g2D = (Graphics2D)g;
Point2D.Double corner1 = new Point2D.Double(100, 50);
Point2D.Double corner2 = new Point2D.Double(50, 150);
Point2D.Double corner3 = new Point2D.Double(150, 150);
}
Line2D.Double side1 = new Line2D.Double(corner1, corner2);
Line2D.Double side2 = new Line2D.Double(corner2, corner3);
Line2D.Double side3 = new Line2D.Double(corner3, corner1);
g2D.draw(side1); g2D.draw(side2);
g2D.draw(side3);
Polygon
java.awt.Polygon implements the Shape
interface.
Specify the x and y coordinates of a closed
polygon's vertices with the following
constructor:
Polygon(int[] xpoints, int[] ypoints, int npoints)
Polygon Example
import java.awt.*;
...
public void paintComponent(Graphics g) {
super.paintComponent(g);
Graphics2D g2D = (Graphics2D)g;
Polygon triangle = new Polygon(new int[] {100, 50, 150},
new int[] {50, 150, 150}, 3);
g2D.draw(triangle); // produces same triangles as before
}
...
Rectangular Shapes
Abstract subclasses of RectangularShape:
Rectangle2D, RoundRectangle2D
Ellipse2D, Arc2D
Each has concrete .Double and .Float subclasses
Each constructor requires x,y coordinate of upper
left corner of bounding rectangle, and also the
rectangle's width and height
Use draw to draw an outline of the shape in the
current color.
Use fill to fill the shape with the current color.
Repaint method
If you need paintComponent to execute
i.e., if you want to update the graphics drawn on a
Swing component
 You can call method repaint
repaint returns void,
 repaint takes no arguments
repaint is inherited by all JComponents indirectly
from class Component (package java.awt).
Additional Parameters for Rounded
Rectangles
(x,y)
arcHei
width
public void paintComponent(Graphics g) {
super.paintComponent(g);
Graphics2D g2D = (Graphics2D)g;
Rectangle2D.Double rect1 =
new Rectangle2D.Double(25,25,100,100);
g2D.setColor(Color.black);
g2D.draw(rect1);
RoundRectangle2D.Double rect2 =
new RoundRectangle2D.Double(50,50,100,100,80,30);
g2D.setColor(Color.green);
g2D.fill(rect2);
Ellipse2D.Double rect3 =
new Ellipse2D.Double(75,75,100,80);
g2D.setColor(Color.blue);
g2D.fill(rect3);
public void paintComponent(Graphics g)
{ super.paintComponent(g);
Graphics2D g2D = (Graphics2D)g;
Arc2D.Double arc =
new Arc2D.Double(25,25,150,100,0,120,Arc2D.PIE);
g2D.setColor(Color.black);
g2D.fill(arc);
arc = new Arc2D.Double(25,25,150,100,120,120,Arc2D.PIE);
g2D.setColor(Color.green);
g2D.fill(arc);
arc = new Arc2D.Double(25,25,150,100,240,120,Arc2D.PIE);
g2D.setColor(Color.orange);
g2D.fill(arc);
public void paintComponent(Graphics g) {
super.paintComponent(g);
Graphics2D g2D = (Graphics2D)g;
Arc2D.Double arc =
new Arc2D.Double(25,25,150,100,0,120,Arc2D.CHORD);
g2D.setColor(Color.black);
g2D.fill(arc);
arc = new Arc2D.Double(25,25,150,100,120,120,Arc2D.CHORD);
g2D.setColor(Color.green);
g2D.fill
arc =new Arc2D.Double(25,25,150,100,240,120,Arc2D.CHORD);
g2D.setColor(Color.orange);
g2D.fill(arc);
}