Apostila Java2D

COMPUTAÇÃO GRÁFICA 2015
Prof.ª M.ª Eng.ª Elaine Cecília Gatto
Página 1 de 25
Page 1 of 25

Página 2 de 25
Page 2 of 25
Sumário
JAVA 2D.........................................................................................................................................................................3
1. Hierarquia de Classes............................................................................................................................................3
2. Sistema de Coordenadas ......................................................................................................................................3
3. Contextos Gráficos................................................................................................................................................3
4. Cores.....................................................................................................................................................................4
4.1 Constantes de Cor...........................................................................................................................................4
4.2 Construtores e métodos Color .......................................................................................................................4
4.3 Métodos Graphics para manipular Colors......................................................................................................4
5. Fontes ...................................................................................................................................................................5
5.1 Construtores, Constantes e métodos de Font................................................................................................5
5.2 Métodos Graphics para manipular Fontes.....................................................................................................5
5.3 Métodos FontMetrics.....................................................................................................................................5
5.3 Métodos Graphics para obter a FontMetrics de uma Font............................................................................5
6. Linhas, retângulos e ovais.....................................................................................................................................6
6.1 Métodos Graphics para desenhar linhas, retângulos e ovais.........................................................................6
7. Arcos.....................................................................................................................................................................7
7.1 Métodos Graphics para desenhar arcos.........................................................................................................8
8. Polígonos e polilinhas...........................................................................................................................................8
8.1 Métodos Graphics para desenhar polígonos..................................................................................................8
8.2 Construtores e Métodos da classe Polygon ...................................................................................................9
9. API Java2D.............................................................................................................................................................9
9.1 Visão Geral....................................................................................................................................................10
9.2 Coordenadas.................................................................................................................................................10
9.3 Renderização ................................................................................................................................................11
9.4 Primitivas Geométricas.................................................................................................................................15
9.5 Textos............................................................................................................................................................16
9.6 Fontes ...........................................................................................................................................................16
9.7 Layout de Texto ............................................................................................................................................17
9.8 Rendering Hints para texto...........................................................................................................................17
9.9 Imagens.........................................................................................................................................................17
9.10 Impressão ...................................................................................................................................................18
9.10 Métodos......................................................................................................................................................18
10. Exercícios ..........................................................................................................................................................24

Página 3 de 25
Page 3 of 25
JAVA 2D
1. Hierarquia de Classes
 Classe Color: contém métodos e constantes para manipular cores
 Método paintComponent: desenha imagens gráficas em um componente
 Classe Font: contém métodos e constantes para manipular fontes
 Classe FontMetrics: contém métodos para obter informações de fontes
 Classe Graphics: contém métodos para desenhar Strings, Linhas, Retângulos e outras formas geométricas básicas
 Classe Graphics2D: estende a classe Graphics, desenha com a API do Java2D
 Classe Polygon: contém métodos para criar polígonos
 Classe BasicStroke: especifica as características de desenho de linhas
 Classes GradientPaint e TexturePaint: especificam as características para preencher formas com cores ou padrões
 Classes General Path, Line2D, Arc2D, Ellipse2D, Rectangule2D e RoudRectangle2D: representam as formas
geométricas
2. Sistema de Coordenadas
 É um esquema para identificar cada ponto na tela
 O canto superior esquerdo de um componente de interface gráfica em Java tem as coordenadas (0,0)
 Coordenada x: coordenada horizontal – é distância horizontal que vai do lado direito ao lado esquerdo da tela
 Coordenada y: coordenada vertical – é a distância vertical de baixo para cima da tela
 Um par de coordenadas é composto pelas coordenadas x e y
 Eixo x: descreve cada coordenada horizontal
 Eixo y: descreve cada coordenada vertical
 Coordenadas são utilizadas para indicar onde as imagens gráficas devem ser exibidas na tela
 Pixels: unidade de medida. É a menos unidade de exibição de resolução de um monitor.
3. Contextos Gráficos
 Um contexto gráfico em Java permite desenhar na tela
 Objeto Graphics:
o Gerencia o contexto gráfico
o Desenha pixels na tela
o Contém métodos para desenhar e manipular fontes, cores, etc.
 Como Java é independente de plataforma, as imagens gráficas serão apresentadas na tela conforme o sistema o qual
está executando (Windows, Linux, etc.)
 Classe Component: superclasse
 Classe JComponent: herda de Component, contém o método paintComponent, é uma superclasse de JPanel
 Método paintComponent:
o public void paintComponent(Graphics g)
o Recebe um objeto Graphics como argumento.
o O objeto Graphics é passado para o método paintComponent pelo sistema quando um componente de
interface gráfica precisa ser repintado
o g é um parâmetro que recebe uma referencia a uma instancia da subclasse específica de sistema
 Método repaint:
o é chamado pelo programador para solicitar uma chamada ao método paintComponent.

Página 4 de 25
Page 4 of 25
o public void repaint()
4. Cores
 RGB = red, green, blue
 Valores inteiros: 0 a 255
 Valores de ponto flutuante: 0.0 a 1.0
 16,7 milhões de cores disponíveis no Java
 Objetos Color são imutáveis (isto é, não modificáveis)
 Para alterar as cores, você sempre deve criar um novo objeto Color
 Como alternativa, pode usar uma das constantes Color
4.1 Constantes de Cor
Color Cor Valor RGB
public final static Color RED Vermelho 255,0,0
public final static Color GREEN Verde 0,255,0
public final static Color BLUE Azul 0,0,255
public final static Color ORANGE Laranja 255,200,0
public final static Color PINK Cor-de-rosa 255,175,175
public final static Color CYAN Ciano 0,255,255
public final static Color MAGENTA Magenta 255,0,255
public final static Color YELLOW Amarelo 255,255,0
public final static Color BLACK Preto 0,0,0
public final static Color WHITE Branco 255,255,255
public final static Color GRAY Cinza 128,128,128
public final static Color LIGHT_GRAY Cinza Claro 192,192,192
public final static Color DARK_GRAY Cinza Escuro 64,64,64
4.2 Construtores e métodos Color
Método Descrição
public Color( int r, int g, int b)
Cria uma cor com base nos componentes vermelho, verde, azul,
expressos com valores inteiros entre 0 e 255
public Color( float r, float g, float b)
Cria uma cor com base nos componentes vermelho, verde, azul
expressos com valores de ponto flutuante entre 0.0 e 1.0
public int getRed()
Retorna um valor entre 0 e 255 representando o conteúdo
vermelho
public int getGreen() Retorna um valor entre 0 e 255 representando o conteúdo verde
public int getBlue() Retorna um valor entre 0 e 255 representando o conteúdo azul
4.3 Métodos Graphics para manipular Colors
Método Descrição
public Color getColor() Retorna o objeto Color que representa as cores atuais no contexto gráfico
Public void setColor(Color c) Configura a cor atual para desenho com contexto gráfico

Página 5 de 25
Page 5 of 25
5. Fontes
 O número de fontes varia de um sistema operacional para outro.
 O Java fornece cinco nomes lógicos de fontes:
o Serif;
o Monospaced;
o SansSerif;
o Dialog;
o DialogInput.
 O JRE em cada plataforma mapeia esses nomes lógicos de fonte para fontes reais instaladas na plataforma
5.1 Construtores, Constantes e métodos de Font
Método Descrição
public final static int PLAIN Uma constante representando um estilo de fonte simples
public final static int BOLD Uma constante representando um estilo de fonte negrito
public final static int ITALIC Uma constante representando um estilo de fonte itálico
public Font(String name, int style,
int size)
Cria um objeto Font com o nome, o estilo e o tamanho de fonte
especificada.
public int getStlye() Retorna um valor inteiro indicando o estilo de fonte atual
public int getSize() Retorna um valor inteiro indicando o tamanho da fonte atual
public String getName() Retorna o nome da fonte atual como uma string
public String getFamily() Retorna o nome da família de fontes como uma string
public boolean isPlain() Retorna true se a fonte for simples, caso contrário false
public boolean isBold() Retorna true se a fonte for negrito, caso contrário false
public boolean isItalic() Retorna true se a fonte for itálica, caso contrário false
5.2 Métodos Graphics para manipular Fontes
Método Descrição
public Font getFont() Retorna uma referência de objeto Font representando a fonte atual
Public void setFont(Font f)
Configura a fonte atual como a fonte, o estilo e o tamanho especificados pela
referência de objeto Font f
5.3 Métodos FontMetrics
Método Descrição
public int getAscent() Retorna a ascendente de uma fonte em pontos
public int getDescent() Retorna a descendente de uma fonte em pontos
public int getLeading() Retorna a entrelinha de uma fonte em pontos
Public int getHeight() Retorna a altura de uma fonte em pontos
5.3 Métodos Graphics para obter a FontMetrics de uma Font
Método Descrição
public FontMetrics getFontMetrics() Retorna o objeto FontMetrics para o desenho atual Font
Public FontMetrics getFontMetrics (Font f)
Retorna o objeto FontMetrics para o argumento Font
especificado

Página 6 de 25
Page 6 of 25
6. Linhas, retângulos e ovais
 Cada método de desenho requer um parâmetro de largura e altura
 Largura e altura devem ser valores não negativos
6.1 Métodos Graphics para desenhar linhas, retângulos e ovais
Método Descrição
public void drawLine(int x1, int y1, int
x2, int y2) Desenha uma linha entre o ponto (x1,y1) e o ponto (x2,y2)
public void drawRect(int x, int y, int
largura, int altura)
Desenha um retângulo com a largura e a altura
especificadas.
O canto superior esquerdo do retângulo tem as coordenadas
(x,y).
Somente o contorno do retângulo é desenhado utilizando a
cor do objeto de Graphics.
O corpo do retângulo não é preenchido com essa cor.
public void fillRect(int x, int y, int
Desenha um retângulo sólido com a largura e a altura
especificadas.
(x,y)
O retângulo é preenchido com a cor do objeto Graphics
public void clearRect(int x, int y, int
Desenha um retângulo preenchido com a largura e a altura
especificadas na cor de fundo atual.
(x,y).
Esse método é útil se o programador quiser remover uma
parte de uma imagem
public void drawRoundRect(int x, int y,
int largura, int altura, int archWidth,
int arcHeight)
Desenha um retângulo com cantos arredondados na cor atual
com a largura e a altura especificadas.
arcWidth e arcHeight determinam o arredondamento dos
cantos
Somente o contorno da forma é desenhado
public void fillRoundRect(int x, int y,
int largura, int altura, int arcWidth, int
arcHeight)
Desenha um retângulo com cantos arredondados na cor atual
com a largura e a altura especificadas.
arcWidth e arcHeight determinam o arredondamento dos
cantos
public void draw3DRect(int x, int y, int
largura, int altura, boolean b)
Desenha um retângulo tridimensional na cor atual com a
largura e a altura especificadas.
(x,y)
O retângulo parece em alto relevo quando b é verdadeiro e
em baixo relevo quando b é falso
public void fill3DRect(int x, int y, int
largura, int altura, boolean b)
Desenha um retângulo tridimensional na cor atual com a
largura e a altura especificadas.
(x,y)
O retângulo parece em alto relevo quando b é verdadeiro e
em baixo relevo quando b é falso
public void drawOval(int x, int y, int
Desenha uma oval na cor atual com a largura e a altura
especificadas

Página 7 de 25
Page 7 of 25
O canto superior esquerdo do retângulo delimitador está nas
coordenadas (x,y)
A oval toca todos os quatro lados do retângulo associado no
centro de cada lado
public void fillOval(int x, int y, int
Desenha uma oval na cor atual com a largura e a altura
especificadas
O canto superior esquerdo do retângulo delimitador está nas
coordenadas (x,y)
A oval toca todos os quatro lados do retângulo associado no
centro de cada lado
Figura 1: Oval unida por um retângulo
Figura 2: Largura e altura do arco para retângulos arredondados
7. Arcos
 Um arco é desenhado como uma parte de uma oval
 Uma oval é delimitada por um retângulo
 Os arcos varrem a partir de um ângulo inicial até o número de graus especificados pelos seus ângulos de arco
 Arcos movem-se ao longo de uma curva
 Os ângulos de arco são medidos em graus
 Arcos varrem, a partir de um ângulo inicial, o número de graus especificado por seu ângulo de arco
 Ao desenhar um arco, especificamos um retângulo delimitador para uma oval
 O arco varrerá parte da oval

Página 8 de 25
Page 8 of 25
7.1 Métodos Graphics para desenhar arcos
Método Descrição
public void drawArc(int x, int y, int
largura, int altura, int anguloInicial,
int anguloDoArco)
Desenha um arco em relação ao canto superior esquerdo do
retângulo delimitador e coordenadas x e y com a largura e a
altura especificadas.
O segmento de arco começa a ser desenhado no
anguloInicial e a curva, no anguloDoArco
public void fillArc(int x, int y, int
largura, int altura, int anguloInicial,
int anguloDoArco)
Desenha um arco preenchido – um setor – em relação as
coordenadas x e y do canto superior esquerdo do retângulo
delimitador com a largura e a altura especificadas.
O segmento de arco começa a ser desenhado no
anguloInicial e a curva, no anguloDoArco
Figura 3: Ângulos de arco positivo
Figura 4: Ângulos de arco negativo
8. Polígonos e polilinhas
 Polígonos são formas de múltiplos lados compostas de segmentos de linhas retas
 Polilinhas são sequencias de pontos conectados
8.1 Métodos Graphics para desenhar polígonos
Método Descrição
public void drawPoligon(int xPoints[], int Desenha um polígono

Página 9 de 25
Page 9 of 25
yPoints[], int points) A coordenada x de cada ponto é especificada no array
xPoints, e a coordenada y de cada ponto, no array yPoints
O último argumento especifica o número de points
Esse método desenha um polígono
Se o último ponto for diferente do primeiro, o polígono é
fechado por uma linha que conecta o último ponto ao
primeiro
public void drawPolyline(int xPoints[],
int yPoints[], int points)
Desenha uma sequencia de linhas conectadas
A coordenada x de cada ponto é especificada no array
xPoints, e a coordenada y de cada ponto é especificada no
arrayPoints
Se o último ponto for diferente do primeiro, a polilinha não
é fechada
public void drawPolygon(Polygon p) Desenha o polígono especificado
public void fillPolygon(int xPoints[], int
yPoints[], int points)
Desenha um polígono preenchido
A coordenada x de cada ponto é especificada no array
xPoints, e a coordenada y de cada ponto é especificada no
arrayPoints
Esse método desenha um polígono
Se o último ponto for diferente do primeiro, o polígono é
fechado por uma linha que conecta o último ponto a primeiro
public void fillPolygon(Polygon g)
Desenha o polígono preenchido especificado.
O polígono é fechado
8.2 Construtores e Métodos da classe Polygon
Método Descrição
public Polygon()
Constrói um novo objeto polígono
O polígono não contem nenhum ponto
public Polygon(int xValues[], int
yValues[], int numberOfPoints)
Constrói um novo objeto de polígono
O polígono tem numberOfPoints lados, com cada ponto
consistindo em uma coordenada x de xValues e uma
coordenada y de yValues
public void addPoint(int x, int y) Adiciona pares das coordenadas x e y ao Polygon
9. API Java2D
 Recursos para processamento de:
o line art (traço)
o texto
o imagens
 Pacotes:
o Java.awt.image
o Java.awt.color

Página 10 de 25
Page 10 of 25
o Java.awt.font
o Java.awt.geom
o Java.awt.print
o Java.awt.image.renderable
 Graphics2D
o Subclasse abstrata da classe Graphics
o Contém capacidades gráficas
o Para acessar as capacidades de Graphics2D, devemos fazer a coerção da referência Graphics (g) passada a
paintComponent para uma referência Graphics2D com a instrução Graphics2D g2d = (Graphics2D) g;
9.1 Visão Geral
A API Java 2D fornece gráficos bidimensionais, texto e recursos de imagens para programas Java através de
extensões para o Abstract Windowig Toolkit (AWT). Este pacote de renderização abrangente suporta linha art, texto e imagens
em uma estrutura flexível, cheia de recursos para o desenvolvimento de interfaces ricas de usuário, programas de desenho
sofisticados e editores de imagem. Objetos Java 2D existem em um plano chamado de coordenadas do espaço, ou apenas o
espaço do usuário. Quando os objetos são processados em uma tela ou uma impressora, as coordenadas de espaço do usuário
são transformadas em coordenadas espaciais do dispositivo. A API Java 2D fornece seguintes capacidades:
o Um modelo de rendereização uniforme de dispositivos de exibição e impressoras;
o Uma ampla gama de primitivas geométricas, tais como retângulos, curvas, e elipses, bem como um
mecanismo para renderizar virtualmente qualquer forma geométrica;
o Mecanismos de desempenho e detecção em formas, texto e imagens;
o Um modelo de composição que fornece controle sobre como os objetos de sobreposição são processados;
o Suporte de cor aprimorada, que facilita o gerenciamento de cores;
o Suporte para a impressão de documentos complexos;
o Controle da qualidade da renderização através da utilização de render.
A classe Graphics2D estende a classe Graphics para fornecer um controle mais sofisticado sobre a geometria,
transformações de coordenadas, gerenciamento de cores e layout de texto. Esta classe é fundamental para renderizar e
dimensionar formas, textos e imagens na plataforma Java.
9.2 Coordenadas
A API Java 2D mantém dois espaços de coordenadas: espaço do usuário e espaço do dispositivo.
Espaço do usuário: O espaço em que os gráficos primitivos são especificados. Espaço do usuário é um sistema
lógico de coordenadas independente do dispositivo, o espaço de coordenadas que seu programa usa. Todas as formas
geométricas passadas para rotinas de renderização 2D do Java são especificados em coordenadas de espaço do usuário.

Página 11 de 25
Page 11 of 25
Espaço do dispositivo: O sistema de um dispositivo de saída de coordenadas, tais como uma tela, uma janela ou uma
impressora. Espaço do dispositivo é um sistema de coordenadas dependentes do dispositivo que varia de acordo com o
dispositivo de processamento alvo. Embora o sistema de coordenadas para uma janela ou tela pode ser muito diferente do
sistema de coordenadas de uma impressora, estas diferenças são invisíveis para programas Java. As conversões necessárias
entre o espaço do usuário e espaço de dispositivo são executadas automaticamente durante o processamento.
Quando a transformação padrão a partir do espaço do usuário para o espaço do dispositivo é utilizada, a origem do
espaço do usuário é o canto superior esquerdo da área de desenho do componente. A coordenada x aumenta para a direita, e a
coordenada y aumenta para baixo. O canto superior esquerdo de uma janela é 0,0. Todas as coordenadas são especificadas
usando números inteiros, o que é geralmente suficiente. No entanto, alguns casos exigem ponto flutuante de precisão dupla, ou
mesmo que também são suportados.
Todas as coordenadas passadas para um objeto Graphics2D são especificadas em um sistema independente de
dispositivo de coordenadas chamado espaço do usuário, que é usado por aplicativos. O objeto contém um objeto Graphics2D
AffineTransform como parte de seu estado de renderização que define como converter coordenadas de espaço do usuário para
coordenadas dependentes do dispositivo no espaço de dispositivos.
Coordenadas em espaço de dispositivo geralmente se referem a dispositivos individuais pixels e estão alinhados sobre
as lacunas infinitamente finas entre esses pixels. Alguns objetos Graphics2D podem ser usados para capturar as operações de
renderização para armazenamento em um metarquivo gráfico para reprodução em um dispositivo desconhecido concreto de
resolução física em um momento posterior. Uma vez que a resolução não pode ser conhecida quando as operações de
renderização são capturadas, o Graphics2D Transform está configurado para transformar as coordenadas do usuário para um
espaço de dispositivo virtual que aproxima a resolução esperada do dispositivo de destino. Outras transformações podem
precisar ser aplicadas no período de reprodução, se a estimativa é incorreta.
Algumas das operações realizadas pela renderização de atributos e objetos ocorrem no espaço de dispositivo, mas
todos os métodos Graphics2D usam coordenadas espaciais do usuário. Todo objeto Graphics2D está associado a um alvo que
define onde a renderização ocorre. Um objeto GraphicsConfiguration define as características do alvo de renderização, como
formato e resolução de pixel. O mesmo alvo de processamento é utilizado durante toda a vida de um objeto Graphics2D.
Ao criar um objeto Graphics2D, o GraphicsConfiguration especifica a transformação padrão para o destino do
Graphics2D (um componente ou imagem). Esta transformação padrão mapeia o sistema de coordenadas de espaço do usuário
para as coordenadas de tela e dispositivo de impressora. A escala da transformação padrão está definida para a identidade para
aqueles dispositivos que estão perto de 72 dpi, tais como dispositivos de tela. A escala da transformação padrão está definida
para aproximadamente 72 o espaço de coordenadas do usuário por polegada quadrada para dispositivos de alta resolução,
como impressoras. Para buffers de imagem, transformação padrão é a transformação identidade.
9.3 Renderização
A API Java 2D fornece um modelo de renderização uniforme entre os diferentes tipos de dispositivos. No nível do
aplicativo, o processo de renderização é o mesmo se o alvo dispositivo de renderização é uma tela ou uma impressora. Quando

Página 12 de 25
Page 12 of 25
um componente precisa ser exibido, a sua pintura ou método de atualização é automaticamente invocado com o contexto
gráfico apropriado.
A API Java 2D inclui a classe java.awt.Graphics2D, que estende a classe Graphics para fornecer acesso aos gráficos
melhorados e renderização recursos da API do Java 2D. Esses recursos incluem:
 Renderização do esboço de qualquer primitiva geométrica, utilizando os atributos de pintura (método paint).
 Renderização de qualquer primitiva geométrica, preenchendo seu interior com a cor ou o padrão especificado pelos
atributos de paint (método draw).
 Renderização de qualquer seqüência de texto (método drawString). O atributo de fonte é usado para converter a
seqüência de glifos, que são preenchidos com a cor ou o padrão especificado pelos atributos de paint.
 Renderização da imagem especificada (o método drawImage).
Além disso, a classe Graphics2D suporta os métodos de renderização de gráficos para formatos específicos, como
drawOval e fillRect. Todos os métodos que são representados acima podem ser divididos em dois grupos: Métodos para
desenhar uma forma e Métodos que afetam a renderização. O segundo grupo dos métodos utiliza os atributos de estado que
formam o contexto Graphics2D para:
 Variar a largura do traçado
 Alterar a forma como formas são unidas
 Definir um caminho de recorte para limitar a área
 Traduzir, girar, escalar, cisalhar objetos quando eles são renderizados
 Definir cores e padrões para preencher formas
 Especificar como compor vários objetos gráficos
Para empregar recursos da API Java 2D na sua aplicação, uma coersão do objeto Graphics que é passado para método
de renderização de um componente a um objeto Graphics2D deve ser realizada. Por exemplo:
public void paint (Graphics g) {
Graphics2D g2 = (Graphics2D) g;
... }
O contexto de renderização classe Graphics2D contém vários atributos. O atributo pen é aplicado ao contorno de uma
forma. Este atributo permite que você desenhe linhas com qualquer tamanho de ponto e padrão de linha. O atributo fill é
aplicado ao interior da forma. Este atributo permite que você preencha formas com cores sólidas, gradientes e padrões. O
atributo de compositing é usado quando os objetos se sobrepõem a objetos existentes. O atributo de transform é aplicado
durante o processamento para converter o objeto processado a partir do espaço do usuário para as coordenadas do dispositivo e
do espaço. Transformações opcionais como translação, rotação, dimensionamento ou corte também podem ser aplicados por
este atributo. O clip restringe a renderização para a área dentro do contorno do objeto usado para definir o caminho de recorte.
Qualquer objeto da forma pode ser usado para definir o clip. O atributo font é usado para converter sequências de texto para
glifos. Hit rendering especifica preferências entre velocidade e qualidade. Por exemplo, você pode especificar se a suavização
deve ser utilizada, se esse recurso estiver disponível. Quando um atributo é definido, o objeto de atributo apropriado é passado.

Página 13 de 25
Page 13 of 25
Como mostra o exemplo, para alterar o atributo de paint para um azul-esverdeado de preenchimento gradiente, você deve
construir um objeto GradientPaint e, em seguida, chamar o método setPaint.
gp = new GradientPaint(0f,0f,blue,0f,30f,green);
g2.setPaint(gp);
9.3.1 Processo de Renderização
O processo de renderização pode ser dividido em quatro fases, que são controladas pelos atributos de renderização
Graphics2D. O processador pode otimizar muitos desses passos, seja por cache os resultados para futuras chamadas, como por
passos virtuais múltiplos em uma operação simples, como por reconhecer vários atributos como casos comuns ou simples que
podem ser elimiados pela modificação de parte das operações. As etapas do processo de renderização são:
1. Determine o que renderizar;
2. Restringir a operação de renderização para o clip atual. O clip é especificado por uma forma no espaço do usuário e
é controlado pelo programa usando os vários métodos de manipulação de clip de gráficos e Graphics2D. Este clip do
usuário é transformado em espaço dispositivo pela Transformada atual e combinado com o clip do dispositivo, a qual
é definida pela visibilidade de janelas e as extensões do dispositivo. A combinação do clip do usuário e o do
dispostivo define o clip compósito, que determina a última região de recorte. O clip do usuário não é modificado pelo
sistema de renderização para refletir o clip compósito resultante.
3. Determinar quais cores serão renderizadas;
4. Aplicar as cores para a superfície de desenho destino usando o atributo Composite atual no contexto Graphics2D.
Os três tipos de operações de renderização, juntamente com os detalhes de cada um dos seus processos de
transformação específicos são:
1. Operações de forma
 Se a operação for um draw (Forma) operação, então o método createStrokedShape no atributo do traçado
corrente no contexto Graphics2D é utilizado para construir um novo objeto de forma que contém o contorno
da forma especificada.
 O Shape é transformado a partir do espaço do usuário para o espaço do dispositivo usando a Transformada
atual no contexto Graphics2D.
 O contorno da forma é extraído utilizando o método getPathIterator de Shape, que retorna um objeto
PathIterator que itera ao longo do limite do Shape.
 Se o objeto Graphics2D não consegue lidar com os segmentos de curva que o objeto PathIterator retorna em
seguida, ele pode chamar o método alternativo getPathIterator de Shape, que achata a Shape.
 A pintura atual no contexto Graphics2D é consultado para um contexto de Paint, que especifica as cores para
renderizar no espaço dispositivo.

Página 14 de 25
Page 14 of 25
2. Operações de Texto
 Os passos seguintes são usados para determinar o conjunto de glifos necessários para tornar a seqüência
indicada:
o Se o argumento for uma cadeia de caracteres, então a fonte corrento no contexto Graphics2D é
solicitada a converter os caracteres Unicode no String em um conjunto de glifos para a apresentação
com qualquer layout básico e moldar os algoritmos de fonte implementados;
o Se o argumento é um AttributedCharacterIterator, o iterador é solicitado a converter-se a um
TextLayout usando seus atributos de fonte incorporados. O TextLayout implementa algoritmos mais
sofisticados de layout de glifo que realizam ajustes de layout Unicode bi-direcional
automaticamente para várias fontes de diferentes direções de escrita;
o Se o argumento é um GlyphVector, então o objeto GlyphVector já contém os códigos de glifos
específicos de fonte apropriados com coordenadas explícitas para a posição de cada glifo.
 A fonte atual é consultada para obtenção de contornos para os glifos indicados. Estes contornos são tratados
como formas no espaço do usuário em relação à posição de cada glifo que foi determinada no passo 1.
 Os contornos de caracteres são preenchidos como acima indicado no âmbito de ações de forma.
 A pintura atual é consultada para um PaintContext, que especifica as cores para renderizar no espaço
dispositivo.
3. Operações de imagem
 A região de interesse é definida pela caixa delimitadora da Fonte da imagem. Esta caixa delimitadora é
especificada na imagem do espaço, que é o sistema de coordenadas local do objeto de imagem.
 Se um AffineTransform é passado para drawImage (Imagem, AffineTransform, ImageObserver), o
AffineTransform é utilizado para transformar a caixa delimitadora do espaço de imagem do espaço do
usuário. Se nenhum AffineTransform é fornecido, a caixa delimitadora é tratada como se ela já estivesse no
espaço do usuário.
 A caixa delimitadora da Fonte da imagem é transformada a partir do espaço do usuário para o espaço do
dispositivo usando Transformada. Note-se que o resultado da transformação da caixa delimitadora não
resulta necessariamente numa região retangular no espaço dispositivo.
 O objeto de imagem determina as cores que serão renderizadas, recolhidas de acordo com a origem para o
destino mapeado de coordenadas especificado pelo atual Transform e a imagem transformação de imagem.
9.3.2 Problemas de Compatibilidade de Renderização
O modelo de renderização do JDK (TM) 1.1 baseia-se num modelo pixelization que especifica que as coordenadas
são infinitamente finas, que se encontram entre os pixels. Operações de estiramento são realizadas usando uma caneta de
largura de um pixel que enche o pixel abaixo e para a direita do ponto de ancoragem no caminho. O modelo é consistente com

Página 15 de 25
Page 15 of 25
as capacidades da maioria das classes existentes de representantes de plataformas que precisam resolver coordenadas inteiras a
uma caneta discreta que deve ser completamente em um número especificado de pixels.
O Java 2D (tm) (Java (TM) 2 plataforma) API suporta renderizadores de anti-serrilhamento. Uma caneta com uma
largura de um pixel não precisa ser completamente em N pixels em oposição ao pixel de N + 1. A caneta pode ser parcialmente
em ambos os pixels. Não é necessário escolher uma direção de polarização para uma caneta de largura, desde que a mistura
que ocorre ao longo das bordas da caneta de passagem faça com que a posição de sub-pixels da caneta seja visível para o
usuário. Por outro lado, quando antialiasing está desligado, definindo a chave KEY_ANTIALIASING para o valor
VALUE_ANTIALIAS_OFF, o processador pode precisar aplicar um viés para determinar quais pixels modificar quando a
caneta está montando uma fronteira de pixels, como quando é desenhada ao longo de um número inteiro de coordenadas no
espaço de dispositivo.
API Java 2D mantém a compatibilidade com JDK 1.1 no seu comportamento de processamento, de tal forma que as
operações de legado e comportamento renderizador não é alterado sob API Java 2D. Graphics2D estende gráficos com base
nas configurações do Curso e transformam atributos e hints de renderização. A definição executa de forma idêntica sob
configurações de atributo padrão. Por exemplo, o curso padrão é um BasicStroke com uma largura de 1 e não arrojado e o
padrão Transform para o desenho da tela é a transformação identidade.
9.4 Primitivas Geométricas
A API Java 2D fornece um conjunto útil de formatos padrão, como pontos, linhas, retângulos, arcos, elipses e curvas.
O pacote mais importante para definir primitivas geométricas comuns é o pacote java.awt.geom. Formatos arbitrários podem
ser representados pelas combinações de primitivas geométricas. A interface SHAPE representa uma forma geométrica, que tem
um contorno e um interior. Essa interface fornece um conjunto comum de métodos para descrever e inspecionar objetos
geométricos bidimensionais e apoia segmentos de linha curvos e várias sub-formas. A classe Graphics suporta apenas
segmentos de linha reta. A interface SHAPE pode suportar segmentos de curvas.
9.4.1 Pontos
A classe Point2D define um ponto que representa um local em (x, y) de coordenadas de espaço. O termo "ponto" na
API Java 2D não é o mesmo que um pixel. Um ponto não tem nenhuma área, não contém uma cor, e não pode ser processado.
Os pontos são usados para criar outras formas. A classe Point2D também inclui um método para calcular a distância entre dois
pontos.
9.4.2 Linhas
A classe Line2D é uma classe abstrata que representa uma linha. Coordenadas de uma linha podem ser recuperadas
como um double. A classe Line2D inclui vários métodos para definir pontos de extremidade de uma linha. Você também pode
criar um segmento de linha reta usando a classe GeneralPath.

Página 16 de 25
Page 16 of 25
9.4.3 Formas Retangulares
As primitivas Rectangle2D, RoundRectangle2D, Arc2D, e Ellipse2D são todos derivados da classe RectangularShape.
Esta classe define métodos para objetos Shape que podem ser descritos por uma caixa delimitadora retangular. A geometria de
um objeto RectangularShape podem ser extrapolados a partir de um rectângulo que envolve completamente o contorno da
forma.
9.4.4 Curvas
O QuadCurve2D permite que você crie segmentos de curva quadrática paramétrica. Uma curva quadrática é definida
por dois pontos finais e um ponto de controle. A classe CubicCurve2D permite que você crie segmentos de curva paramétrica
cúbicas. Uma curva cúbica é definida por dois pontos de extremidade e dois pontos de controle.
9.4.5 Formas Arbitrárias
A classe GeneralPath permite construir uma forma arbitrária, especificando uma série de posições ao longo do limite
da forma. Estas posições podem ser ligadas por segmentos de linha, curvas quadráticas, ou (curvas Bezier) cúbicas. Um
caminho geral é uma forma construída a partir de linhas retas e curvas complexas. Um caminho geral é representado com um
objeto da classe GeneraPath.
9.4.6 Áreas
Com a classe Area, você pode executar operações booleanas, como a união, intersecção, subtração e, em quaisquer
dois objetos Shape. Esta técnica, muitas vezes referida como área de geometria construtiva, permite que você crie rapidamente
objetos Shape complexos sem ter de descrever cada segmento de linha ou curva.
9.5 Textos
A API Java 2D tem vários recursos de renderização de texto, incluindo os métodos de renderização de strings para
definir os atributos de fonte e layout de texto. Se você quiser apenas desenhar uma cadeia de texto estático, o caminho mais
direto é usar a classe Graphics por meio do método drawString. Para especificar a fonte, você usa o método setFont da classe
Graphics. Se você quiser implementar suas próprias rotinas de edição de texto ou se precisar de mais controle sobre o layout do
texto do que os componentes de texto fornecem, você pode usar as classes de layout de texto Java 2D no pacote java.awt.font.
9.6 Fontes
As formas que uma fonte usa para representar os caracteres em uma seqüência de caracteres são chamados glifos. Um
caracter em particular ou combinação de caracteres pode ser representada como um ou mais glifos. Por exemplo, a pode ser
representado por dois glifos, enquanto que a palavra fi pode ser representada por um único glifo. Uma fonte pode ser pensada

Página 17 de 25
Page 17 of 25
como uma coleção de grifos. Uma única fonte pode ter muitas faces, como itálico e regular. Todas as faces de uma fonte tem
características tipográficas semelhantes e podem ser reconhecidos como membros da mesma família. Em outras palavras, uma
coleção de glifos com um estilo particular formar uma face de fonte. Uma coleção de faces de fonte forma uma família de
fontes. A coleção de famílias de fontes forma o conjunto de fontes que estão disponíveis no sistema. Quando você estiver
usando a API do Java 2D, você deve especificar fontes usando uma instância de Font. Você pode determinar quais fontes estão
disponíveis chamando o método GraphicsEnvironment.getLocalGraphicsEnvironment e depois consultar o
GraphicsEnvironment retornado. O método getAllFonts retorna uma matriz que contém instâncias de fonte para todas as fontes
disponíveis no sistema. O método getAvailableFontFamilyNames retorna uma lista das famílias de fontes disponíveis.
9.7 Layout de Texto
São dois os mecanismos do Java 2D para o gerenciamento de layout de texto: 1. A classe TextLayout gerencia a
disposição do texto. As facilidades proporcionadas pelo TextLayout está em lidar com os casos mais comuns, incluindo strings
com fontes mistas, lingaugens mistass e texto bidirecional; 2. Você pode criar objetos GlyphVector usando a classe Font e, em
seguida, tornando cada objeto GlyphVector através da classe Graphics2D. Assim, você pode completamente controlar como o
texto é moldado e posicionado.
9.8 Rendering Hints para texto
A API Java 2D permite que você controle a qualidade de formas e renderização de texto usando rendering hints.
Rendering Hints são encapsulados pela classe java.awt.RenderingHints. Tal como aplicado a texto, esta capacidade é usada
para suavização (que também é conhecido como arestas lisas). Por exemplo, o hint KEY_TEXT_ANTIALIASING permite-lhe
controlar a suavização de texto separadamente da suavização de outras formas.
9.9 Imagens
Na API Java 2D uma imagem é tipicamente uma matriz bidimensional retangular de pixels, em que cada pixel
representa a cor nessa posição da imagem e em que as dimensões representam a extensão horizontal (largura) e a extensão
vertical (altura) da imagem como ele é exibido. A classe de imagem mais importante para a representação de tais imagens é a
classe java.awt.image.BufferedImage. A API Java 2D armazena o conteúdo de tais imagens na memória para que eles possam
ser acessados diretamente. Os aplicativos podem criar diretamente um objeto BufferedImage ou obter uma imagem de um
formato de imagem externo, como PNG ou GIF. Em ambos os casos, o aplicativo pode, então, desenhar sobre a imagem
usando chamadas de API do Java 2D Graphics. Assim, as imagens não estão limitadas a exibição de imagens fotográficas.
Diferentes objetos como line art, texto e outros gráficos e até mesmo outras imagens podem ser desenhados para uma imagem.
A API Java 2D permite que você aplique operações de filtragem de imagem para BufferedImage e inclui diversos filtros
embutidos. Por exemplo, o filtro ConvolveOp pode ser usado para a nitidez de imagens. A imagem resultante pode então ser
enviada para uma tela, para uma impressora ou salva em um formato gráfico, como PNG, GIF etc.

Página 18 de 25
Page 18 of 25
9.10 Impressão
Todo componente Swing e Gráficos Java 2D, incluindo gráficos e imagens compostas, podem ser processados para
uma impressora usando a API do Java Printing 2D. Esta API também fornece características de composição que lhe permitem
realizar operações como alterar a ordem em que as páginas são impressas. Renderização em uma impressora é como
renderização para uma tela. O sistema de impressão controla quando as páginas são renderizadas, assim como os controles do
sistema de desenho quando um componente é pintado na tela. A API Java Printing 2D é baseado em um modelo de retorno de
chamada em que o sistema de impressão, não o aplicativo, controla quando as páginas são impressas. O aplicativo fornece o
sistema de impressão com informações sobre o documento a ser impresso, e o sistema de impressão determina quando cada
página precisa ser trabalhada. As duas características seguintes são importantes para suportar a impressão: 1. Controle do
trabalho: iniciar e gerenciar o trabalho de impressão, incluindo a exibição das caixas de diálogo de impressão e configuração
padrão; 2. Paginação: Renderização de cada página quando o sistema de impressão solicitar. Quando as páginas precisam ser
trabalhadas, o sistema de impressão chama o método de impressão do aplicativo com um contexto de gráficos adequado. Para
usar os recursos da API Java 2D quando você imprime, você lança o objeto Graphics a uma classe Graphics2D, assim como
você faz quando você vai renderizar na tela.
9.10 Métodos
Método Descrição
public abstract void
addRenderingHints(Map<?,?> hints)
Define os valores de um número arbitrário de preferências para os
algoritmos de processamento. Apenas os valores para os hints de
processamento que estão presentes no objeto Map especificado
são modificados. Todas as outras preferências não presentes no
objeto especificado são deixadas sem modificações. Hints
Rendering incluem controles para renderização qualidade e tempo
/ qualidade geral no processo de renderização. Consulte a classe
RenderingHints para definições de algumas chaves e valores
comuns.
public abstract void clip(Shape s)
Intercepta o clip atual com o interior da forma especificada e
define o clip para o cruzamento resultante. A forma especificada é
transformada com o Graphics2D atual antes de ser cruzado com o
clip atual. Este método é usado para fazer o clip corrente menor.
Para fazer o clip maior, use SetClip. O clipe modificado por este
método é independente do recorte associado com os limites do
dispositivo e visibilidade. Se nenhum clip foi previamente
definido, ou se o clip tenha sido apagado usando SetClip com um
argumento nulo, o formato especificado se torna o novo clip do
usuário.
public abstract void draw(Shape s)
Strokes o contorno de uma forma usando as configurações do
contexto Graphics2D atual. Os atributos de renderização aplicadas
incluem o Clip, transformações, paint, composição e atributos de
traçado.
public void draw3DRect(int x,
int y, int width, int height,
boolean raised)
Desenha um retângulo 3D especificado. As bordas do retângulo
são destacadas para que apareçam a ser recortada e iluminada a

Página 19 de 25
Page 19 of 25
partir do canto superior esquerdo. As cores utilizadas para o efeito
de realce são determinadas com base na cor atual. O retângulo
resultante abrange uma área que é largura + 1 pixels de largura por
altura + 1 pixels de altura. Este método usa a cor corrente de
COLOR exclusivamente ignorando a cor corrente de Paint
drawGlyphVector(GlyphVector g, float
x, float y)
Processa o texto da GlyphVector especificado usando atributos de
renderização do contexto Graphics2D. Os atributos de
renderização aplicadas incluem o Clip, Transform, Paint, e
atributos compostos. O GlyphVector especifica glifos individuais
a partir de uma fonte. O GlyphVector também pode conter as
posições glifo. Este é o caminho mais rápido para processar um
conjunto de caracteres para a tela.
drawImage(BufferedImage img,
BufferedImageOp op,
int x, int y)
Processa um BufferedImage que é filtrada com um
BufferedImageOp. Os atributos de renderização aplicadas incluem
o Clip, Transform e atributos compostos. Isto é equivalente a:
img1 = op.filter(img, null);
drawImage(img1, new
AffineTransform(1f,0f,0f,1f,x,y), null);
public abstract boolean
drawImage(Image img, AffineTransform
xform ImageObserver obs)
Transmite uma imagem, aplicando uma transformação do espaço
de imagem para o espaço do usuário antes de desenhar. A
transformação do espaço do utilizador para o espaço do
dispositivo é feito com a atual Transformada no Graphics2D. A
transformação especificada é aplicada à imagem antes do atributo
transformação no contexto Graphics2D ser aplicado.. Os atributos
de renderização aplicadas incluem o clip, Transform e atributos
compostos. Note-se que nenhuma renderização será feita se a
transformação especificada é noninvertible.
drawRenderableImage(RenderableImage
img, AffineTransform xform)
Processa um RenderableImage, aplicando uma transformação do
espaço de imagem para o espaço do usuário antes de desenhar. A
transformação do espaço do usuário para o espaço do dispositivo é
feito com a atual Transformada no Graphics2D. A transformação
especificada é aplicada à imagem antes do atributo transformação
no contexto Graphics2D ser aplicado. Os atributos de renderização
aplicadas incluem o clip, Transform e atributos compostos. Note-
se que nenhuma renderização será feita se a transformação
especificada é noninvertible. Hints Rendering definidas no objeto
Graphics2D podem ser usadas na geração da RenderableImage. Se
o controle explícito é necessário sobre hints rendering
reconhecidas por uma RenderableImage específico, ou se o
conhecimento de quais hints são utilizados é necessário, em
seguida, um RenderedImage devem ser obtidos diretamente do
RenderableImage e renderizar usando drawRenderedImage.
drawRenderedImage(RenderedImage img,
AffineTransform xform)
Processa um RenderedImage, aplicando uma transformação do
espaço de imagem para o espaço do usuário antes de desenhar. A
transformação do espaço do usuário para o espaço do dispositivo é
feito com a atual Transformada no Graphics2D. A transformação
especificada é aplicada à imagem antes do atributo transformação
no contexto Graphics2D ser aplicado. Os atributos de renderização
aplicadas incluem o clipe, Transformar e atributos compostos.

Página 20 de 25
Page 20 of 25
Note-se que nenhuma renderização será feita se a transformação
especificada é noninvertible.
drawString(AttributedCharacterIterator
iterator,float x,float y)
Processa o texto do iterador especificado aplicando seus atributos,
de acordo com a especificação da classe TextAttribute. A linha de
base do primeiro caractere está na posição (x, y) no espaço do
usuário. Para caracteres em sistemas de escrita, como hebraico e
árabe, os glifos podem ser renderizados a partir da direita para a
esquerda, caso em que a coordenada fornecida é o local do
caractere mais à esquerda na linha de base.
drawString(AttributedCharacterIterator
iterator,int x, int y)
Processa o texto do iterador especificado aplicando seus atributos,
de acordo com a especificação da classe TextAttribute. A linha de
usuário. Para caracteres em sistemas de escrita, como hebraico e
árabe, os glifos podem ser renderizados a partir da direita para a
esquerda, caso em que a coordenada fornecida é o local do
caractere mais à esquerda na linha de base.
public abstract void drawString(String
str, float x, float y)
Processa o texto especificado pela String especificada, usando o
estado do atributo text atual no contexto Graphics2D. A linha de
usuário. Os atributos de renderização aplicados incluem o Clip,
Transform, Paint, Font e atributos compostos. Para caracteres em
sistemas de escrita, como hebraico e árabe, os glifos podem ser
renderizados a partir da direita para a esquerda, caso em que a
coordenada fornecida é o local do caractere mais à esquerda na
linha de base.
public abstract void drawString(String
str,int x,int y)
Processa o texto especificado pela String especificada, usando o
estado do atributo text atual no contexto Graphics2D. A linha de
usuário. Os atributos de renderização aplicadas incluem o Clip,
Transform, Paint, Font e atributos compostos. Para caracteres em
sistemas de escrita, como hebraico e árabe, os glifos podem ser
renderizados a partir da direita para a esquerda, caso em que a
coordenada fornecida é o local do caractere mais à esquerda na
linha de base.
public abstract void fill(Shape s)
Preenche o interior de um Shape usando as configurações do
contexto Graphics2D. Os atributos de renderização aplicadas
incluem o Clip, Transform, Paint, e Composite.
public void fill3DRect(int x, int y,
int width, int height,boolean raised)
Pinta um retângulo 3D preenchido com a cor atual. As bordas do
retângulo são destacadas para que ele apareça como se as bordas
fossem chanfradas e iluminadas a partir do canto superior
esquerdo. As cores utilizadas para o efeito de realce e para o
enchimento são determinadas a partir de cores atuais. Este método
usa a cor atual de COLOR exclusiva e ignora o PAINT atual.
public abstract Color getBackground()
Retorna a cor de fundo usada para limpar uma região.
public abstract Composite
getComposite() Retorna o atual Composite no contexto Graphics2D.
public abstract GraphicsConfiguration
getDeviceConfiguration() Retorna a configuração do dispositivo associado a este

Página 21 de 25
Page 21 of 25
Graphics2D.
public abstract FontRenderContext
getFontRenderContext()
Obter o contexto de renderização da fonte dentro deste contexto
Graphics2D. O FontRenderContext encapsula hints tais como
anti-aliasing e métricas fracionárias, bem como informações
específicas do dispositivo de destino, tais como pontos por
polegada. Esta informação deve ser fornecida pelo aplicativo ao
utilizar objetos que realizam a formatação tipográfica, como Fonte
e TextLayout. Esta informação também deve ser fornecida por
aplicações que executam seu próprio layout e necessite de
medidas precisas e várias características de glifos, como
sobrescrito e altura da linha quando vários hints rendering forem
aplicados para a renderização de texto.
public abstract Paint getPaint()
Retorna a pintura atual do contexto Graphics2D.
public abstract Object
getRenderingHint(RenderingHints.Key
hintKey)
Retorna o valor de uma única preferência para os algoritmos de
processamento. Hints Rendering incluem controles para
renderização qualidade e tempo / qualidade trade-off geral no
processo de renderização.
public abstract RenderingHints
getRenderingHints()
Obtém as preferências para os algoritmos de processamento.
Categorias dica incluem controles para renderização qualidade e
tempo / qualidade trade-off geral no processo de renderização.
Retorna todos os pares chave hint / valor que já foram
especificados em uma operação.
public abstract Stroke getStroke()
Retorna o curso atual no contexto Graphics2D.
public abstract AffineTransform
getTransform() Retorna uma cópia do atual Transform no contexto Graphics2D.
public abstract boolean hit(Rectangle
rect, Shape s, boolean onStroke)
Verifica se ou não a forma especificada intercepta o retângulo
especificado, que está em espaço de dispositivo. Se onStroke é
false, esse método verifica se ou não o interior da forma
especificada intercepta o retângulo especificado. Se onStroke é
verdade, este método verifica se ou não o traçado do contorno da
forma especificada intercepta o retângulo especificado. Os
atributos de renderização tidos em conta incluem o Clip,
Transform, e os atributos de traçado.
public abstract void rotate(double
theta)
Concatena o atual Graphics2D Transform com uma rotação
transformar. Renderização subsequente é executado pelo radianos
especificados em relação à origem anterior. Isso é equivalente a
chamar transform (R), onde R é um AffineTransform representado
pela seguinte matriz:
[ cos(theta) -sin(theta) 0 ]
[ sin(theta) cos(theta) 0 ]
[ 0 0 1 ]
Rotativo com um teta ângulo positivo gira pontos no eixo x
positivo para o eixo y positivo.
public abstract void rotate(double
theta, double x, double y) Concatena o atual Graphics2D Transform com uma transformação
de rotação translação. Renderização subsequente é transformada

Página 22 de 25
Page 22 of 25
por uma transformação que é construída por traduzir para o local
especificado, executando pelos radianos especificados, e traduzir
de volta pelo mesmo montante que a tradução original. Isto é
equivalente à seguinte sequência de chamadas:
translate(x, y);
rotate(theta);
translate(-x, -y);
Rotativo com um teta ângulo positivo gira pontos no eixo x
positivo para o eixo y positivo.
public abstract void scale(double sx,
double sy)
Concatena o atual Graphics2D Transform com uma transformação
de escala. A renderização subsequente é redimensionada de
acordo com os fatores de escala especificados relativos ao
dimensionamento anterior. Isso é equivalente a chamar transform
(S), onde S é um AffineTransform representado pela seguinte
matriz:
[ sx 0 0 ]
[ 0 sy 0 ]
[ 0 0 1 ]
setBackground(Color color)
Define a cor de fundo para o contexto Graphics2D. A cor de fundo
é usada para limpar a região. Quando um Graphics2D é construído
para um componente, a cor de fundo é herdada do componente.
Definir a cor de fundo no contexto Graphics2D afeta apenas as
chamadas subseqüentes clearRect e não a cor de fundo para o
componente. Para alterar o plano de fundo do componente, use
métodos adequados do componente.
setComposite(Composite comp)
Define o Composite para o contexto Graphics2D. O composto é
usado em todos os métodos de desenho como drawImage,
drawString, paint e fill. Ele especifica como novos pixels devem
ser combinados com os pixels existentes no dispositivo gráficos
durante o processo de renderização. Se neste contexto Graphics2D
está chegando ao Componente na tela de exibição e o Composite é
um objeto personalizado, em vez de uma instância da classe
AlphaComposite, e se houver um gerente de segurança, o seu
método checkPermission é chamado com um AWTPermission
("readDisplayPixels") permissão.
public abstract void setPaint(Paint
paint)
Define o atributo de pintura para o contexto Graphics2D. Chamar
esse método com um objeto pintura nulo não tem qualquer efeito
sobre o atributo de pintura atual deste Graphics2D.
setRenderingHint(RenderingHints.Key
hintKey, Object hintValue)
Define o valor de uma única preferência para os algoritmos de
processamento. Rendering Hint incluem controles para
setRenderingHints(Map<?,?> hints)
Substitui os valores de todas as preferências para os algoritmos de
processamento com os hints especificadas. Os valores existentes
para todas as referências de renderização são descartados e um
novo conjunto de sugestões e valores conhecidos são inicializados
a partir do objeto Map especificado. Incluem controles para

Página 23 de 25
Page 23 of 25
public abstract void setStroke(Stroke
s) Define o curso para o contexto Graphics2D.
setTransform(AffineTransform Tx)
Substitui o Transform no contexto Graphics2D. AVISO: Este
método nunca deve ser usado para aplicar uma nova coordenada
transformada em cima de uma transformação existente porque o
Graphics2D já pode ter uma transformação que é necessária para
outros fins, tais como renderização de componentes Swing ou
aplicar uma transformação de escala para ajustar a resolução de
uma impressora. Para adicionar uma transformação, use os
métodos transform, rotate, scale ou shear. O método setTransform
é destinado apenas para restaurar o Graphics2D original conforme
o exemplo:
// Get the current transform
AffineTransform saveAT = g2.getTransform();
// Perform transformation
g2d.transform(...);
// Render
g2d.draw(...);
// Restore original transform
g2d.setTransform(saveAT);
public abstract void shear(double shx,
double shy)
Concatena o atual Graphics2D Transform com um corte de
transformação. Representações subsequentes são cortados pelo
multiplicador relativo especificado para a posição anterior. Isso é
equivalente a chamar de transformação (SH), onde SH é uma
AffineTransform representado pela seguinte matriz:
[ 1 shx 0 ]
[ shy 1 0 ]
[ 0 0 1 ]
transform(AffineTransform Tx)
Compõe um objeto AffineTransform com a Transformada neste
Graphics2D de acordo com a regra “last-specified-first-applied”.
Se a Transform atual é Cx, o resultado da composição com Tx é
um novo Transform Cx '. Cx 'se torna a Transformada atual para
este Graphics2D. Transformar um ponto p pela Transformada
atualizada Cx 'é equivalente ao primeiro transformador p por Tx e,
em seguida, transformar o resultado do original Transform Cx. Em
outras palavras, Cx '(p) = Cx (Tx (p)). Uma cópia do Tx é feita, se
necessário, para mais alterações Tx não afeta a renderização.
public abstract void translate(double
tx, double ty)
Concatena o atual Graphics2D Transform com uma translação. A
Renderização subsequente é traduzida pela distância especificada
em relação à posição anterior. Isso é equivalente a chamar de
transformação (T), onde T é uma AffineTransform representado
pela seguinte matriz:
[ 1 0 tx ]
[ 0 1 ty ]
[ 0 0 1 ]
public abstract void translate(int x,
int y) Traduz a origem do contexto Graphics2D para o ponto (x, y) no

Página 24 de 25
Page 24 of 25
atual sistema de coordenadas. Modifica o contexto Graphics2D
para que sua nova origem corresponda ao ponto (x, y) no sistema
de coordenadas do contexto Graphics2D. Todas as coordenadas
utilizadas em operações de renderização subseqüentes neste
contexto gráfico são relativas a esta nova origem.
10. Exercícios
Para todos os exercícios listados abaixo, desenvolver um aplicativo Java, usando os recursos da API Java2D.
10.1 Desenhe uma série de oito círculos concêntricos. Os círculos devem estar separados por 10 pixels usando o método
drawArc.
10.2 Desenhe uma série de oito círculos concêntricos. Os círculos devem estar separados por 10 pixels usando o método
Ellipse2D
10.3 Desenhe linhas aleatórias com cores e espessuras aleatórias usando Line2D.
10.4 Desenhe três triângulos gerados aleatoriamente em cores diferentes. Cada triangulo deve ser preenchido com uma cor
diferente. Use GeneralPath.
10.5 Desenhe aleatoriamente caracteres em diferentes tamanhos de fontes e cores.
10.6 Desenhe uma grade de 8 X 8 usando o método drawLine.
10.7 Desenhe uma grade de 10 X 10 usando o método drawRect.
10.8 desenhe uma grade 10 X 10 usando o método Rectangle2D.
10.9 Desenhe um tetraedro (pirâmide) usando GeneralPath.
10.10 Desenhe um cubo usando GeneralPath.
10.11 Desenvolva um aplicativo que solicita ao usuário inserir o raio de um círculo como um número de ponto flutuante e
desenha o círculo, bem como os valores do diâmetro do círculo, circunferência e área. Também deve ser solicitado ao usuário
um conjunto de coordenadas além do raio. Desenhe o circulo e exiba o diâmetro, a circunferência e a área do círculo utilizando
um objeto Ellipse2D para representar o círculo e o método draw da classe Graphics2D para exibi-lo. Use o valor 3.14159 para
o PI.
REFERÊNCIAS
API Java2D. Acesso em: 10 de Setembro de 2015. Disponível em:
https://docs.oracle.com/javase/8/docs/api/java/awt/Graphics2D.html.
Tutorial Java2D. Acesso em: 10 de Setembro de 2015. Disponível em: https://docs.oracle.com/javase/tutorial/2d/
Deitel, Deitel. Java Como Programar. 8.ª edição. Editora Pearson.

Página 25 de 25
Page 25 of 25

Apostila Java2D

Mais conteúdo relacionado

Semelhante a Apostila Java2D (20)

Mais de Elaine Cecília Gatto (20)

Último (20)

Apostila Java2D