java.awt.Graphics<\/code> class. This lesson covers the most common needs of applications developers.
\nMost methods of the Graphics class can be divided into two basic groups:<\/p>\n\n\n- Draw and fill methods, enabling you to render basic shapes, text, and images.<\/li>\n
- Attributes setting methods, which affect how that drawing and filling appears.<\/li>\n<\/ul>\n<\/ul>\n
Methods such as setFont and setColor define how draw and fill methods render.
\nDrawing methods include:<\/p>\n
\n\n\n- drawString \u2013 For drawing text<\/li>\n
- drawImage \u2013 For drawing images<\/li>\n
- drawLine, drawArc, drawRect, drawOval, drawPolygon \u2013 For drawing geometric shapes<\/li>\n<\/ul>\n<\/ul>\n<\/ul>\n
Depending on your current need, you can choose one of several methods in the Graphics class based on the following criteria:<\/p>\n
\n\n\n- Whether you want to render the image at the specified location in its original size or scale it to fit inside the given rectangle.<\/li>\n
- Whether you prefer to fill the transparent areas of the image with color or keep them transparent.<\/li>\n<\/ul>\n<\/ul>\n<\/ul>\n
Fill methods apply to geometric shapes and include fillArc, fillRect, fillOval, fillPolygon.\u00a0Whether you draw a line of text or an image, remember that in 2D graphics every point is determined by its x and y coordinates. All of the draw and fill methods need this information which determines where the text or image should be rendered..<\/p>\n
For example, to draw a line, an application calls the following:<\/p>\n
AWTGraphicsExample.java<\/em><\/span><\/p>\njava.awt.Graphics.drawLine(int x1, int y1, int x2, int y2)\r\n<\/pre>\n2. The java.awt.Graphics Class: Graphics Context and Custom Painting<\/h2>\n
A graphics context provides the capabilities of drawing on the screen. The graphics context maintains states such as the color and font used in drawing, as well as interacting with the underlying operating system to perform the drawing. In Java, custom painting is done via the java.awt.Graphics<\/code> class, which manages a graphics context, and provides a set of device-independent methods for drawing texts, figures and images on the screen on different platforms.<\/p>\nThe java.awt.Graphics<\/code> is an abstract class, as the actual act of drawing is system-dependent and device-dependent. Each operating platform will provide a subclass of Graphics to perform the actual drawing under the platform, but conform to the specification defined in Graphics.<\/p>\n2.1 Graphics Class’ Drawing Methods<\/h3>\n
The Graphics class provides methods for drawing three types of graphical objects:<\/p>\n
1.Text strings: via the drawString()<\/code> method. Take note that System.out.println() prints to the system console, not to the graphics screen.
\n2.Vector-graphic primitives and shapes: via methods rawXxx()<\/code> and fillXxx()<\/code>, where Xxx could be Line, Rect, Oval, Arc, PolyLine, RoundRect, or 3DRect.
\n3.Bitmap images: via the drawImage()<\/code> method.<\/p>\nAWTGraphicsExample.java<\/em><\/span><\/p>\n\/\/ Drawing (or printing) texts on the graphics screen:\r\ndrawString(String str, int xBaselineLeft, int yBaselineLeft);\r\n \r\n\/\/ Drawing lines:\r\ndrawLine(int x1, int y1, int x2, int y2);\r\ndrawPolyline(int[] xPoints, int[] yPoints, int numPoint);\r\n \r\n\/\/ Drawing primitive shapes:\r\ndrawRect(int xTopLeft, int yTopLeft, int width, int height);\r\ndrawOval(int xTopLeft, int yTopLeft, int width, int height);\r\ndrawArc(int xTopLeft, int yTopLeft, int width, int height, int startAngle, int arcAngle);\r\ndraw3DRect(int xTopLeft, int, yTopLeft, int width, int height, boolean raised);\r\ndrawRoundRect(int xTopLeft, int yTopLeft, int width, int height, int arcWidth, int arcHeight)\r\ndrawPolygon(int[] xPoints, int[] yPoints, int numPoint);\r\n \r\n\/\/ Filling primitive shapes:\r\nfillRect(int xTopLeft, int yTopLeft, int width, int height);\r\nfillOval(int xTopLeft, int yTopLeft, int width, int height);\r\nfillArc(int xTopLeft, int yTopLeft, int width, int height, int startAngle, int arcAngle);\r\nfill3DRect(int xTopLeft, int, yTopLeft, int width, int height, boolean raised);\r\nfillRoundRect(int xTopLeft, int yTopLeft, int width, int height, int arcWidth, int arcHeight)\r\nfillPolygon(int[] xPoints, int[] yPoints, int numPoint);\r\n \r\n\/\/ Drawing (or Displaying) images:\r\ndrawImage(Image img, int xTopLeft, int yTopLeft, ImageObserver obs); \/\/ draw image with its size\r\ndrawImage(Image img, int xTopLeft, int yTopLeft, int width, int height, ImageObserver o); \/\/ resize image on screen\r\n<\/pre>\n2.2 Graphics Class’ Methods for Maintaining the Graphics Context<\/h3>\n
The graphic context maintains states (or attributes) such as the current painting color, the current font for drawing text strings, and the current painting rectangular area (called clip). You can use the methods getColor()<\/code>, setColor()<\/code>, getFont()<\/code>, setFont()<\/code>, getClipBounds()<\/code>, setClip()<\/code> to get or set the color, font, and clip area. Any painting outside the clip area is ignored.<\/p>\nAWTGraphicsExample.java<\/em><\/span><\/p>\n\/\/ Graphics context's current color.\r\nvoid setColor(Color c)\r\nColor getColor()\r\n \r\n\/\/ Graphics context's current font.\r\nvoid setFont(Font f)\r\nFont getFont()\r\n\r\n\/\/ Set\/Get the current clip area. Clip area shall be rectangular and no rendering is performed outside the clip area.\r\nvoid setClip(int xTopLeft, int yTopLeft, int width, int height)\r\nvoid setClip(Shape rect)\r\npublic abstract void clipRect(int x, int y, int width, int height) \/\/ intersects the current clip with the given rectangle\r\nRectangle getClipBounds() \/\/ returns an Rectangle\r\nShape getClip() \/\/ returns an object (typically Rectangle) implements Shape\r\n\r\n<\/pre>\n2.3 Graphics Class’ Other Methods<\/h3>\n
AWTGraphicsExample.java<\/em><\/span> <\/div> <\/div><\/p>\nvoid clearRect(int x, int y, int width, int height)\r\n \/\/ Clear the rectangular area to background\r\nvoid copyArea(int x, int y, int width, int height, int dx, int dy)\r\n \/\/ Copy the rectangular area to offset (dx, dy).\r\nvoid translate(int x, int y)\r\n \/\/ Translate the origin of the graphics context to (x, y). Subsequent drawing uses the new origin.\r\nFontMetrics getFontMetrics()\r\nFontMetrics getFontMetrics(Font f)\r\n \/\/ Get the FontMetrics of the current font \/ the specified font\r\n\r\n<\/pre>\n2.4 Graphics Coordinate System<\/h3>\n
In Java Windowing Subsystem (like most of the 2D Graphics systems), the origin (0,0) is located at the top-left corner.<\/p>\n
EACH component\/container has its own coordinate system, ranging for (0,0) to (width-1, height-1) as illustrated.<\/p>\n
You can use method getWidth() and getHeight() to retrieve the width and height of a component\/container. You can use getX() or getY() to get the top-left corner (x,y) of this component’s origin relative to its parent.<\/p>\n
3 Custom Painting Template<\/h2>\n
Under Swing, custom painting is usually performed by extending (i.e., subclassing) a JPanel<\/code> as the drawing canvas and override the paintComponent(Graphics g)<\/code> method to perform your own drawing with the drawing methods provided by the Graphics class. The Java Windowing Subsystem invokes (calls back) paintComponent(g)<\/code> to render the JPanel<\/code> by providing the current graphics context g, which can be used to invoke the drawing methods.<\/p>\nThe extended JPanel is often programmed as an inner class of a JFrame<\/code> application to facilitate access of private variables\/methods. Although we typically draw on the JPanel<\/code>, you can in fact draw on any JComponent<\/code> (such as JLabel, JButton).<\/p>\nThe custom painting code template is as follows:<\/p>\n
AWTGraphicsExample.java<\/em><\/span><\/p>\nimport java.awt.*; \/\/ Using AWT's Graphics and Color\r\nimport java.awt.event.*; \/\/ Using AWT event classes and listener interfaces\r\nimport javax.swing.*; \/\/ Using Swing's components and containers\r\n \r\n\/** Custom Drawing Code Template *\/\r\n\/\/ A Swing application extends javax.swing.JFrame\r\npublic class CGTemplate extends JFrame {\r\n \/\/ Define constants\r\n public static final int CANVAS_WIDTH = 640;\r\n public static final int CANVAS_HEIGHT = 480;\r\n \r\n \/\/ Declare an instance of the drawing canvas,\r\n \/\/ which is an inner class called DrawCanvas extending javax.swing.JPanel.\r\n private DrawCanvas canvas;\r\n \r\n \/\/ Constructor to set up the GUI components and event handlers\r\n public CGTemplate() {\r\n canvas = new DrawCanvas(); \/\/ Construct the drawing canvas\r\n canvas.setPreferredSize(new Dimension(CANVAS_WIDTH, CANVAS_HEIGHT));\r\n \r\n \/\/ Set the Drawing JPanel as the JFrame's content-pane\r\n Container cp = getContentPane();\r\n cp.add(canvas);\r\n \/\/ or \"setContentPane(canvas);\"\r\n \r\n setDefaultCloseOperation(EXIT_ON_CLOSE); \/\/ Handle the CLOSE button\r\n pack(); \/\/ Either pack() the components; or setSize()\r\n setTitle(\"......\"); \/\/ \"super\" JFrame sets the title\r\n setVisible(true); \/\/ \"super\" JFrame show\r\n }\r\n \r\n \/**\r\n * Define inner class DrawCanvas, which is a JPanel used for custom drawing.\r\n *\/\r\n private class DrawCanvas extends JPanel {\r\n \/\/ Override paintComponent to perform your own painting\r\n @Override\r\n public void paintComponent(Graphics g) {\r\n super.paintComponent(g); \/\/ paint parent's background\r\n setBackground(Color.BLACK); \/\/ set background color for this JPanel\r\n \r\n \/\/ Your custom painting codes. For example,\r\n \/\/ Drawing primitive shapes\r\n g.setColor(Color.YELLOW); \/\/ set the drawing color\r\n g.drawLine(30, 40, 100, 200);\r\n g.drawOval(150, 180, 10, 10);\r\n g.drawRect(200, 210, 20, 30);\r\n g.setColor(Color.RED); \/\/ change the drawing color\r\n g.fillOval(300, 310, 30, 50);\r\n g.fillRect(400, 350, 60, 50);\r\n \/\/ Printing texts\r\n g.setColor(Color.WHITE);\r\n g.setFont(new Font(\"Monospaced\", Font.PLAIN, 12));\r\n g.drawString(\"Testing custom drawing ...\", 10, 20);\r\n }\r\n }\r\n \r\n \/\/ The entry main method\r\n public static void main(String[] args) {\r\n \/\/ Run the GUI codes on the Event-Dispatching thread for thread safety\r\n SwingUtilities.invokeLater(new Runnable() {\r\n @Override\r\n public void run() {\r\n new CGTemplate(); \/\/ Let the constructor do the job\r\n }\r\n });\r\n }\r\n}\r\n<\/pre>\n Dissecting the Program<\/strong> <\/b><\/p>\n\n\n\n\n- Custom painting is performed by extending a
JPanel<\/code> (called DrawCanvas) and overrides the paintComponent(Graphics g)<\/code> method to do your own drawing with the drawing methods provided by the Graphics class.<\/li>\n- DrawCanvas is designed as an inner class of this JFrame application, so as to facilitate access of the private variables\/methods.<\/li>\n
- Java Windowing Subsystem invokes (calls back)
paintComponent(g)<\/code> to render the JPanel<\/code>, with the current graphics context in g, whenever there is a need to refresh the display (e.g., during the initial launch, restore, resize, etc). You can use the drawing methods (g.drawXxx() and g.fillXxx()) on the current graphics context g to perform custom painting on the JPanel<\/code>.<\/li>\n- The size of the
JPanel<\/code> is set via the setPreferredSize()<\/code>. The JFrame<\/code> does not set its size, but packs the components contained via pack().<\/li>\n- In the main(), the constructor is called in the event-dispatch thread via static method
javax.swing.SwingUtilities.invokeLater()<\/code> (instead of running in the main thread), to ensure thread-safety and avoid deadlock, as recommended by the Swing developers.<\/li>\n<\/ul>\n<\/ul>\n<\/ul>\n<\/ul>\n3.1 Refreshing the Display via repaint()<\/h3>\n
At times, we need to explicitly refresh the display (e.g., in game and animation). We shall NOT invoke paintComponent(Graphics)<\/code> directly. Instead, we invoke the JComponent’s repaint() method. The Windowing Subsystem will in turn call back the paintComponent()<\/code> with the current Graphics context and execute it in the event-dispatching thread for thread safety. You can repaint() a particular JComponent<\/code> (such as a JPanel) or the entire JFrame<\/code>. The children contained within the JComponent<\/code> will also be repainted.<\/p>\n4. Colors and Fonts<\/h2>\n4.1 java.awt.Color<\/h3>\n
The class java.awt.Color provides 13 standard colors as named-constants. They are: Color.RED, GREEN, BLUE, MAGENTA, CYAN, YELLOW, BLACK, WHITE, GRAY, DARK_GRAY, LIGHT_GRAY, ORANGE, and PINK. (In JDK 1.1, these constant names are in lowercase, e.g., red. This violates the Java naming convention for constants. In JDK 1.2, the uppercase names are added. The lowercase names were not removed for backward compatibility.)<\/p>\n
You can use the toString() to print the RGB values of these color (e.g., System.out.println(Color.RED)):<\/p>\n
AWTGraphicsExample.java<\/em><\/span><\/p>\nRED : java.awt.Color[r=255, g=0, b=0]\r\nGREEN : java.awt.Color[r=0, g=255, b=0]\r\nBLUE : java.awt.Color[r=0, g=0, b=255]\r\nYELLOW : java.awt.Color[r=255, g=255, b=0]\r\nMAGENTA : java.awt.Color[r=255, g=0, b=255]\r\nCYAN : java.awt.Color[r=0, g=255, b=255]\r\nWHITE : java.awt.Color[r=255, g=255, b=255]\r\nBLACK : java.awt.Color[r=0, g=0, b=0]\r\nGRAY : java.awt.Color[r=128, g=128, b=128]\r\nLIGHT_GRAY: java.awt.Color[r=192, g=192, b=192]\r\nDARK_GRAY : java.awt.Color[r=64, g=64, b=64]\r\nPINK : java.awt.Color[r=255, g=175, b=175]\r\nORANGE : java.awt.Color[r=255, g=200, b=0]\r\n<\/pre>\nTo retrieve the individual components, you can use getRed(), getGreen(), getBlue(), getAlpha(), etc.<\/p>\n
To set the background and foreground (text) color of a component\/container, you can invoke:<\/p>\n
AWTGraphicsExample.java<\/em><\/span><\/p>\nJLabel label = new JLabel(\"Test\");\r\nlabel.setBackground(Color.LIGHT_GRAY);\r\nlabel.setForeground(Color.RED);\r\n<\/pre>\n4.2 java.awt.Font<\/h3>\n
The class java.awt.Font<\/code> represents a specific font face, which can be used for rendering texts. You can use the following constructor to construct a Font instance:<\/p>\nAWTGraphicsExample.java<\/em><\/span><\/p>\npublic Font(String name, int style, int size);\r\n\/\/ name: Family name \"Dialog\", \"DialogInput\", \"Monospaced\", \"Serif\", or \"SansSerif\" or\r\n\/\/ Physical font found in this GraphicsEnvironment.\r\n\/\/ You can also use String constants Font.DIALOG, Font.DIALOG_INPUT, Font.MONOSPACED, \r\n\/\/ Font.SERIF, Font.SANS_SERIF (JDK 1.6)\r\n\/\/ style: Font.PLAIN, Font.BOLD, Font.ITALIC or Font.BOLD|Font.ITALIC (Bit-OR)\r\n\/\/ size: the point size of the font (in pt) (1 inch has 72 pt).\r\n<\/pre>\nYou can use the setFont()<\/code> method to set the current font for the Graphics context g for rendering texts. For example,<\/p>\nAWTGraphicsExample.java<\/em><\/span><\/p>\nFont myFont1 = new Font(Font.MONOSPACED, Font.PLAIN, 12);\r\nFont myFont2 = new Font(Font.SERIF, Font.BOLD | Font.ITALIC, 16); \/\/ bold and italics\r\nJButton btn = new JButton(\"RESET\");\r\nbtn.setFont(myFont1);\r\nJLabel lbl = new JLabel(\"Hello\");\r\nlbl.setFont(myFont2);\r\n......\r\ng.drawString(\"In default Font\", 10, 20); \/\/ in default font\r\nFont myFont3 = new Font(Font.SANS_SERIF, Font.ITALIC, 12);\r\ng.setFont(myFont3);\r\ng.drawString(\"Using the font set\", 10, 50); \/\/ in myFont3\r\n<\/pre>\nFont’s Family Name vs. Font Name<\/strong><\/b><\/p>\nA font could have many faces (or style), e.g., plain, bold or italic. All these faces have similar typographic design. The font face name, or font name for short, is the name of a particular font face, like “Arial”, “Arial Bold”, “Arial Italic”, “Arial Bold Italic”. The font family name is the name of the font family that determines the typographic design across several faces, like “Arial”. For example,<\/p>\n
AWTGraphicsExample.java<\/em><\/span><\/p>\njava.awt.Font[family=Arial,name=Arial,style=plain,size=1]\r\njava.awt.Font[family=Arial,name=Arial Bold,style=plain,size=1]\r\njava.awt.Font[family=Arial,name=Arial Bold Italic,style=plain,size=1]\r\njava.awt.Font[family=Arial,name=Arial Italic,style=plain,size=1]\r\n<\/pre>\nLogical Font vs. Physical Font<\/strong><\/b><\/p>\nJDK supports these logical font family names: “Dialog”, “DialogInput”, “Monospaced”, “Serif”, or “SansSerif”. JDK 1.6 provides these String constants: Font.DIALOG, Font.DIALOG_INPUT, Font.MONOSPACED, Font.SERIF, Font.SANS_SERIF.<\/p>\n
Physical font names are actual font libraries such as “Arial”, “Times New Roman” in the system.<\/p>\n
GraphicsEnvironment’s getAvailableFontFamilyNames() and getAllFonts()<\/strong><\/b><\/p>\nYou can use GraphicsEnvironment’s getAvailableFontFamilyNames() to list all the font family names; and getAllFonts()<\/code> to construct all Font instances (with font size of 1 pt). For example,
\nGraphicsEnvironment env = GraphicsEnvironment.getLocalGraphicsEnvironment();<\/p>\nAWTGraphicsExample.java<\/em><\/span><\/p>\n \r\n\/\/ Get all font family name in a String[]\r\nString[] fontNames = env.getAvailableFontFamilyNames();\r\nfor (String fontName : fontNames) {\r\n System.out.println(fontName);\r\n}\r\n \r\n\/\/ Construct all Font instance (with font size of 1)\r\nFont[] fonts = env.getAllFonts();\r\nfor (Font font : fonts) {\r\n System.out.println(font);\r\n}\r\n<\/pre>\nThe Output of the code when executed will look like the one below.<\/p>\n
![\"AWTGraphicsExample.java\"](\"http:\/\/examples.javacodegeeks.com\/wp-content\/uploads\/2016\/08\/awt.jpg\")
<\/a>