Classe Java.Awt.Color

Se você estiver dominando o Java Abstract Toolkit, terá que aprender as aplicações do Java AWT Color Class. Como há muitos construtores e métodos envolvidos, pode parecer intimidante no início. Mas não se preocupe, nós ajudamos você :) Com este resumo completo do Java AWT Color, você aprenderá como criar um novo tipo de cor e gerenciá-lo rapidamente. Também ofereceremos alguns testes práticos que o ajudarão a aprimorar sua habilidade.

O que é classe de cores AWT em Java?

O objetivo principal do AWT Color é permitir que os desenvolvedores criem novas cores usando código Java usando pacotes RGB (vermelho, verde, azul), RGBA (vermelho, verde, azul, alfa) ou HSB (matiz, saturação, componentes BRI). A classe contém dois valores - o código da sombra e o valor da opacidade/transparência. Veja como você declara a classe java.awt.Color:

public class Color
   extends Object
      implements Paint, Serializable

Para declarar diferentes tipos de cores usando Class.java.awt.Color, os desenvolvedores usam construtores - vamos dar uma olhada neles agora.

Construtores AWT.Color em Java

Dependendo do parâmetro da cor que você deseja criar, você precisará usar um tipo específico de construtor de cores. Há um punhado deles - vamos examiná-los um por um.

• Color(float r, float g, float b)é a classe que você usa para definir uma cor opaca no esquema de cores RGB. Você pode especificar o intervalo de cores entre 0,0 e 0,1.
• Color(float r, float b, float g, float a)é a classe que define uma cor RGBA (o intervalo de valores disponíveis é 0,0 e 0,1).
• Color(ColorSpace c, float[], co, float a)define uma cor no ColorSpace especificado anteriormente. Um desenvolvedor especifica o intervalo de componentes de cores na matriz flutuante de um alfa definido.
• Color(int, rgb)é uma classe que cria uma cor RGB (opaca). Certifique-se de prestar atenção ao valor do componente do construtor - 16-23 para vermelho, 8-15 para verde, 0-7 para azul.
• Color(int r, int g, int b)- um método usado para definir uma cor RGB opaca. O valor da cor deve estar entre 0 e 255.
• Color(int r, int g, int b, int a)- cria uma cor no esquema RGBA (0-255).
• Color(int rgba, boolean b)é usado para criar cores sRGB dentro de um valor combinado definido. O intervalo de valores abrange 24-31 para alfa, 16-23 para vermelho, 8-15 para verde e 0-7 para azul.

Fora isso, class.awt.color opera com os campos, herdados de Java.awt.Transparency:

• TRANSLUCENTrepresenta se a cor contém ou não valores alfa e tem dois valores - 0 e 1.
• OPAQUEatribui o valor alfa de 1 ao objeto garantindo-lhe total opacidade.
• BITMASKrepresenta o valor absoluto de opacidade ou transparência e está dentro do intervalo de (0;1), onde 0 é transparência total e 1 é opacidade extrema.

Os 15 principais métodos para usar com a classe de cores Java AWT

Para manipular uma cor, ajustar sua escuridão ou brilho, os desenvolvedores Java contam com diferentes métodos. Existem dezenas deles, então você não precisa aprender todos eles de cor. No entanto, quando se trata dos métodos Java AWT Color mais usados, reduzimos a lista para quinze. Lembrar deles sem ter que fazer referência à documentação da API Java seria útil para os desenvolvedores.

mais escura()

O método é usado para criar uma nova cor que é uma versão mais escura da cor que você já definiu. Exemplo :

Color.green.darker()

Se aplicar darker()uma vez não for suficiente para criar a tonalidade que você precisa, sinta-se à vontade para reaplicar o método quantas vezes quiser, conforme mostrado abaixo:

Color.green.darker().darker().darker().darker().darker()

mais brilhante ()

Como o nome sugere, Color brighter()é usado para iluminar a sombra que você já possui. Da mesma forma que darker(), pode ser usado várias vezes por uma única cor. Exemplo :

Color myColor = Color.RED;          

    JLabel label = new JLabel("First Name");
    label.setForeground(myColor.brighter());

int getAlpha()

Se você deseja retornar o componente alfa da sua cor, use este método. Lembre-se de que os valores alfa estão dentro do intervalo de 0 a 255. Segue o exemplo de aplicação e retorno do método. Exemplo :

alpha = Color.black.getAlpha();
return new Color(components[0], components[1], components[2], alpha);

cor estática getColor(String nm)

Os desenvolvedores Java podem usar esse método para localizar uma cor usando as propriedades do sistema. Existem outros métodos que lidam com objetivos semelhantes:

• static Color getColor(String nm, int v)
• static Color getColor(String nm, Color v)

decodificação de cor estática (string nm)

Este método é usado para exibir uma cor como uma string. Após a conclusão da conversão, um desenvolvedor obterá uma cor opaca definida. Exemplo :

public static Color decodeColor(String hexColor) {

 return Color.decode(hexColor);

PaintContext createContext(ColorModel cm, Rectangle r, Rectangle2D r2d, AffineTransform xform, dicas de RenderingHints)

Este método parece complexo, mas é mais fácil de manipular do que parece. Paint Context CreateContext()é usado para definir um padrão de cor sólida repetido. Exemplo :

 public PaintContext createContext(ColorModel cm, Rectangle deviceBounds, Rectangle2D userBounds,

                  AffineTransform xform, RenderingHints hints)

 {
   try
   {
     return new AxialShadingContext(shading, cm, xform, matrix, deviceBounds);
   }
   catch (IOException e)

   {

     LOG.error("An error occurred while painting", e);

     return new Color(0, 0, 0, 0).createContext(cm, deviceBounds, userBounds, xform, hints);

   }
 }
}

float[] getComponents(ColorSpace cspace, float[] compArray)

Este é um método Java que você pode aplicar a uma cor para retornar sua matriz flutuante e componentes alfa. O método se aplica a um dado ColorSpacedefinido por cspace. Exemplo :

public float[] getComponents(ColorSpace cspace, float[] compArray) {

return myColor.getComponents(cspace, compArray);

}

ColorSpace getColorSpace()

Os desenvolvedores Java podem usar esse método para retornar o espaço de cores para uma cor escolhida. Outra forma de obter um espaço de cores para uma determinada entrada é aplicando Arrays.to.String. Esta é uma estratégia mais complexa, como pode ser visto no exemplo abaixo: Exemplos :

public class Main {
  public static void main(String[] args) {

    Color myColor = Color.RED;          

    System.out.println(Arrays.toString(myColor.getComponents(ColorSpace.getInstance(ColorSpace.CS_CIEXYZ),null)));

getHSBColor(float h, float s, float b)

Os desenvolvedores Java aplicam esse método para criar um novo objeto de cor com base nos valores do modelo HSB. Exemplo :

 private Color colorAt(int y)

 {
   return Color.getHSBColor(1 - (float) y / (height - 1), 1, 1);
 }
}

getGreen()	returns the green component in the range 0-255 in the default sRGB space.

getGreen()

Este método Java retorna o valor do componente verde para a cor que você criou. Todos os valores se enquadram no intervalo que corresponde ao verde no esquema de cores RGB. Exemplo :

Color clickBoxColor = new Color(color.getRed(), color.getGreen(), color.getBlue(), 20);

fique vermelho()

Da mesma forma que getGreen(), getRedretorna o valor do componente vermelho de uma determinada cor. Você já viu como o método foi aplicado no exemplo acima.

getBlue()

Este método retorna o valor de azul dentro do intervalo de valores do esquema de cores RGB. Da mesma forma, para o exemplo de uso de getBlue(), consulte a descrição de getGreen().

getAlpha()

O método getAlpha() é usado em Java quando um desenvolvedor deseja encontrar o valor alfa de uma determinada cor. Da mesma forma que RBG, os alfas de todas as cores estão na faixa de 0 a 255. Exemplo : veja como getAlpha()foi usado como parte de um loop.

int alpha = color.getAlpha();
	if (alpha != 255)
	{
		setStrokeAlpha(alpha);
		strokeAlphaSet = true;

getTransparency()

Este método retorna o valor de transparência que você ou outro desenvolvedor especificou para a cor ao criá-la. Exemplo :

public int getTransparency() {

return myColor.getTransparency();

boolean equals(Object obj)

Este método é muito útil se você estiver comparando duas cores entre si. Ele permite que os desenvolvedores Java saibam se dois objetos de cor têm valores iguais. Exemplo :

import java.awt.Color;
public class Main {
  public static void main(String[] a) {
    Color myBlack = new Color(0, 0, 0); // Color black
    Color myWhite = new Color(255, 255, 255); // Color white
    System.out.println(myBlack.equals(myWhite));
  }
}

equals(Objeto obj)

Da mesma forma que boolean equals(Object obj), este é um método comparativo. Nós o usamos para determinar se os objetos coloridos são iguais entre si. Exemplo :

Object a = new Object(); Object b = new Object(); return(a.equals(b));

Guia das principais cores usadas em Java

Agora que você tem uma compreensão dos métodos usados ​​para manipular cores em Java, vamos dar uma olhada nos tipos de campo com os quais você trabalhará. Estas são as cores estáticas reais que os desenvolvedores Java podem definir. Você pode definir uma cor inserindo seu nome (certifique-se de inseri-la exatamente como está escrito na documentação oficial) ou especificando seu valor RGB. Vamos dar uma olhada na paleta que os desenvolvedores usam:

Problemas práticos para usar AWT.Color em Java

Você sente que tem uma base sólida de AWT Color em Java? Vamos testar essas habilidades resolvendo alguns problemas práticos - aqui, você terá que aplicar construtores e métodos comuns, bem como outras ferramentas Java não relacionadas a cores. Pratique o problema #1 . Crie um componente personalizado que permite ao usuário do programa ajustar os níveis de RGB em uma cor (semelhante a RGBColorChooser). Certifique-se de incluir getColor() em seus componentes. Torne o componente uma subclasse de Panel, não um applet. Resposta : este é um problema bastante complexo - vamos dividi-lo em etapas gerenciáveis:

1. Converter um RGBChooserem um componente.
2. Adicione uma nova rotina ao componente - getColor().
3. Adicione setColor()para definir a cor.

Aqui está o código de amostra que você deve obter no final do dia:

import java.awt.*;
    import java.awt.event.*;
    
    public class RGBChooserComponent extends Panel implements AdjustmentListener {
       
       private Scrollbar redScroll, greenScroll, blueScroll;   // Scroll bars.
       
       private Label redLabel, greenLabel, blueLabel;  // For displaying RGB values.
                     
                     
       private Canvas colorCanvas;  // Color patch for displaying the color.
                     
       public RGBChooserComponent() {  // Constructor.
       
           /*Now let’s add scrollbars with values from 0 to 255. */
           
           redScroll = new Scrollbar(Scrollbar.HORIZONTAL, 0, 10, 0, 265);
           greenScroll = new Scrollbar(Scrollbar.HORIZONTAL, 0, 10, 0, 265);
           blueScroll = new Scrollbar(Scrollbar.HORIZONTAL, 0, 10, 0, 265);
           
           /* Create Labels showing current RGB and HSB values. */
           
           redLabel = new Label(" R = 0");
           greenLabel = new Label(" G = 0");
           blueLabel = new Label(" B = 0");
           
           /* We are setting backgrounds for Scrollbars and Labels, so they get the default
              gray background of the applet. */
           
           redScroll.setBackground(Color.lightGray);
           greenScroll.setBackground(Color.lightGray);
           blueScroll.setBackground(Color.lightGray);
           
           redLabel.setBackground(Color.white);
           greenLabel.setBackground(Color.white);
           blueLabel.setBackground(Color.white);
           
           /* Establish a panel that would listen for changes to the Scrollbars' values */
           
           redScroll.addAdjustmentListener(this);
           greenScroll.addAdjustmentListener(this);
           blueScroll.addAdjustmentListener(this);
           
           /* Add a canva, the background color of which will always match the currently selected color. */
           
           colorCanvas = new Canvas();
           colorCanvas.setBackground(Color.black);
           
           /* Create the applet layout, which consists of a row of
              three equal-sized regions holding the Scrollbars,
              the Labels, and the color patch.  The background color
              of the applet is gray, which will show around the edges
              and between components. */
           
           setLayout(new GridLayout(1,3,3,3));
           setBackground(Color.gray);
           Panel scrolls = new Panel();
           Panel labels = new Panel();
           
           add(scrolls);
           add(labels);
           add(colorCanvas);
           
           /* Add the Scrollbars and the Labels to their respective panels. */
           
           scrolls.setLayout(new GridLayout(3,1,2,2));
           scrolls.add(redScroll);
           scrolls.add(greenScroll);
           scrolls.add(blueScroll);
           
           labels.setLayout(new GridLayout(3,1,2,2));
           labels.add(redLabel);
           labels.add(greenLabel);
           labels.add(blueLabel);
           
       } // end init();
       
       
       public Color getColor() {
              // Get the color currently displayed by the component.
           int r = redScroll.getValue();
           int g = greenScroll.getValue();
           int b = blueScroll.getValue();
           return new Color(r, g, b);
       }
       
       
       public void setColor(Color c) {
             // Set the component to display the given color.
             // (Ignore this if c is null.)
          if (c != null) {
             int r = c.getRed();      // Get the color levels from the color.
             int g = c.getGreen();
             int b = c.getBlue();
             redLabel.setText(" R = " + r);   // Set the labels.
             greenLabel.setText(" G = " + g);
             blueLabel.setText(" B = " + b);
             redScroll.setValue(r);        // Set the scrollbars.
             greenScroll.setValue(g);
             blueScroll.setValue(b);
             colorCanvas.setBackground(new Color(r,g,b));  // Set the canvas.
             colorCanvas.repaint();
          }
       }
       
       
       public Dimension getMinimumSize() {
              // Specify the minimum reasonable size of this component.
          return new Dimension(150,40);
       }
       
       
       public Dimension getPreferredSize() {
              // Specify the preferred size of this component.
          return new Dimension(280,80);
       }
       
    
       public void adjustmentValueChanged(AdjustmentEvent evt) {
               // This is called when the user has changed the values on
               // one of the scrollbars.  All the scrollbars are checked,
               // the labels are set to display the correct values,
               // and the color patch is reset to correspond to the new color.
           int r = redScroll.getValue();
           int g = greenScroll.getValue();
           int b = blueScroll.getValue();
           redLabel.setText(" R = " + r);
           greenLabel.setText(" G = " + g);
           blueLabel.setText(" B = " + b);
           colorCanvas.setBackground(new Color(r,g,b));
           colorCanvas.repaint();  // Redraw the canvas in its new color.
       } // end adjustmentValueChanged
    
       
       public Insets getInsets() {
              // The system calls this method to find out how much space to
              // leave between the edges of the applet and the components that
              // it contains.  I want a 2-pixel border at each edge.
          return new Insets(2,2,2,2);
       }
       
    }  // end class RGBColorChooser

Conclusão

Parabéns, você concluiu este extenso guia sobre AWT.Color em Java. Agora, o manuseio de interfaces será muito mais fácil. Não se esqueça de aplicar seu conhecimento resolvendo problemas práticos e questionários do CodeGym. A prática leva à perfeição, então dê o seu melhor aos problemas de amostra!