Classe java.awt.Color

Si tu travailles avec le Java Abstract Toolkit, tu devras apprendre les applications de la classe Java AWT Color. Comme il y a beaucoup de constructeurs et de méthodes impliqués, cela peut sembler intimidant au début. Mais pas d'inquiétude, nous te couvrons :) Grâce à ce tour d'horizon complet de Java AWT Color, tu apprendras à créer un nouveau type de couleur et à le gérer en un rien de temps. Nous te proposerons également quelques tests pratiques qui te permettront d'affiner tes connaissances.

Qu'est-ce que la classe AWT Color en Java ?

L'objectif principal d'AWT Color est de permettre aux développeurs de créer de nouvelles couleurs à l'aide du code Java en utilisant les packages RGB (rouge, vert, bleu), RGBA (rouge, vert, bleu, alpha) et HSB (teinte, saturation, composantes BRI). La classe contient deux valeurs : le code de la teinte et la valeur d'opacité/transparence. Voici comment déclarer la classe java.awt.Color :

public class Color
   extends Object
      implements Paint, Serializable

Pour déclarer différents types de couleurs à l'aide de la classe java.awt.Color, les développeurs utilisent des constructeurs ; nous allons les examiner maintenant.

Constructeurs AWT.Color en Java

En fonction du paramètre de la couleur que tu veux créer, tu devras utiliser un type spécifique de constructeur de couleur. Il en existe une poignée, examinons-les un par un.

• Color(float r, float g, float b) est la classe que tu utilises pour définir une couleur dans le schéma de couleurs RGB qui est opaque. Tu peux spécifier la gamme de couleurs entre 0,0 et 0,1.

• Color(float r, float b, float g, float a) est la classe qui définit une couleur RGBA (la plage des valeurs disponibles est de 0,0 et 0,1).

• Color(ColorSpace c, float[], co, float a) définit une couleur dans l'espace colorimétrique que tu spécifies au préalable. Le développeur spécifie la plage des composantes de couleur dans le tableau de flottants d'un alpha défini.

• Color(int, rgb) est une classe créant une couleur RGB (opaque). Prête attention à la valeur de la composante du constructeur : 16-23 pour le rouge, 8-15 pour le vert, 0-7 pour le bleu.

• Color(int r, int g, int b) : une méthode utilisée pour définir une couleur RGB opaque. La valeur de la couleur doit être comprise entre 0 et 255.

• Color(int r, int g, int b, int a) : crée une couleur dans le schéma RGBA (0-255).

• Color(int rgba, boolean b) est utilisé pour créer des couleurs sRGB dans une valeur combinée définie. La gamme de valeurs s'étend de 24 à 31 pour l'alpha, de 16 à 23 pour le rouge, de 8 à 15 pour le vert et de 0 à 7 pour le bleu.

En dehors de cela, la classe java.awt.Color fonctionne avec les champs hérités de Java.awt.Transparency :

• TRANSLUCENT indique si la couleur contient ou non des valeurs alpha et a deux valeurs, 0 et 1.

• OPAQUE attribue la valeur alpha 1 à l'objet, ce qui lui garantit une opacité totale.

• BITMASK représente la valeur absolue d'opacité ou de transparence et se situe dans l'intervalle (0;1) où 0 correspond à une transparence totale et 1 à une opacité extrême.

Les 15 meilleures méthodes à utiliser avec la classe Java AWT Color

Pour manipuler une couleur, ajuster son obscurité ou sa luminosité, les développeurs Java s'appuient sur différentes méthodes. Il en existe des dizaines, tu n'as donc pas besoin de les apprendre par cœur. Toutefois, pour ce qui est des méthodes Java AWT Color les plus utilisées, nous avons réduit la liste à quinze. Il est utile pour les développeurs de se souvenir de ces éléments sans avoir à se reporter à la documentation de l'API Java.

darker()

Cette méthode est utilisée pour créer une nouvelle couleur qui est une version plus foncée de la couleur que tu as déjà définie. Exemple :

Color.green.darker()

Si l'application de darker() une fois ne suffit pas à créer la nuance dont tu as besoin, n'hésite pas à réappliquer la méthode autant de fois que tu le souhaites, comme indiqué ci-dessous :

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

brighter()

Comme son nom l'indique, Color brighter() est une méthode utilisée pour éclaircir la couleur que tu as déjà. De la même manière que darker(), elle peut être utilisée plusieurs fois pour une seule couleur. Exemple :

Color myColor = Color.RED;          

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

int getAlpha()

Si tu veux renvoyer la composante alpha de ta couleur, utilise cette méthode. N'oublie pas que les valeurs alpha se situent dans la plage 0-255. Voici un exemple de l'application et du retour de la méthode. Exemple :

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

static Color getColor(String nm)

Les développeurs Java peuvent utiliser cette méthode pour localiser une couleur à l'aide des propriétés système. Il existe d'autres méthodes permettant d'atteindre des objectifs similaires :

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

static Color decode (string nm)

Cette méthode est utilisée pour afficher une couleur sous forme de chaîne. Une fois la conversion terminée, le développeur obtiendra une couleur opaque définie. Exemple :

public static Color decodeColor(String hexColor) {

 return Color.decode(hexColor);

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

Cette méthode semble complexe, mais elle est plus facile à manipuler qu'il n'y paraît. Paint Context CreateContext() est utilisé pour définir un motif de couleur solide répété. Exemple :

 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)

Il s'agit d'une méthode Java que tu peux appliquer à une couleur pour obtenir son tableau de valeurs flottantes et ses composantes alpha. La méthode s'applique à un ColorSpace donné défini par cspace. Exemple :

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

return myColor.getComponents(cspace, compArray);

}

ColorSpace getColorSpace()

Les développeurs Java peuvent utiliser cette méthode pour renvoyer l'espace de couleur d'une couleur choisie. Une autre façon d'obtenir un espace de couleur pour une entrée donnée est d'appliquer Arrays.to.String. Il s'agit d'une stratégie plus complexe, comme le montre l'exemple ci-dessous : Exemples :

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)

Les développeurs Java appliquent cette méthode pour créer un nouvel objet de couleur basé sur les valeurs du modèle HSB. Exemple :

 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()

Cette méthode Java renvoie la valeur de la composante verte pour la couleur que tu as créée. Toutes les valeurs se situent dans la plage qui correspond au vert dans le schéma de couleurs RGB. Exemple :

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

getRed()

Comme getGreen(), getRed renvoie la valeur de la composante rouge d'une couleur donnée. Tu as déjà vu comment la méthode est appliquée dans l'exemple ci-dessus.

getBlue()

Cette méthode renvoie la valeur du bleu dans la plage de valeurs du schéma de couleurs RGB. De même, pour l'exemple d'utilisation de getBlue(), vois la description de getGreen().

getAlpha()

La méthode getAlpha() est utilisée en Java lorsqu'un développeur souhaite trouver la valeur alpha d'une couleur donnée. Comme pour le RGB, les alphas de toutes les couleurs se situent dans la plage 0-255. Exemple : voici comment getAlpha() a été utilisé dans le cadre d'une boucle.

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

getTransparency()

Cette méthode renvoie la valeur de transparence que toi ou un autre développeur avez spécifiée pour la couleur lors de sa création. Exemple :

public int getTransparency() {

return myColor.getTransparency();

boolean equals(Object obj)

Cette méthode est très utile si tu compares deux couleurs entre elles. Elle permet aux développeurs Java de savoir si deux objets de couleur ont des valeurs égales. Exemple :

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(Object obj)

De même que boolean equals(Object obj), celle-ci est une méthode comparative. Nous l'utilisons pour déterminer si des objets de couleur sont égaux les uns aux autres. Exemple :

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

Guide des principales couleurs utilisées en Java

Maintenant que tu as compris les méthodes utilisées pour manipuler les couleurs en Java, examinons les types de champs avec lesquels tu vas travailler. Ce sont les couleurs statiques réelles que les développeurs Java peuvent définir. Tu peux définir une couleur en saisissant son nom (attention à le saisir exactement comme il est écrit dans la documentation officielle) ou en spécifiant sa valeur RGB. Jetons un coup d'œil à la palette utilisée par les développeurs :

Problèmes d'entraînement pour l'utilisation de AWT.Color en Java

Tu sens que tu as une base solide pour AWT Color en Java ? Testons ces compétences en résolvant quelques problèmes pratiques : ici, tu devras appliquer les constructeurs et les méthodes courantes, ainsi que d'autres outils Java non liés aux couleurs. Problème d'entraînement #1. Crée un composant personnalisé qui permet à l'utilisateur du programme de modifier les niveaux RGB d'une couleur (comme avec RGBColorChooser). Veille à inclure getColor() dans tes composants. Fais du composant une sous-classe de Panel, et non une applet. Réponse : il s'agit d'un problème assez complexe ; décomposons-le en étapes gérables :

1. Convertis un RGBChooser en un composant.
2. Ajoute une nouvelle routine au composant : getColor().
3. Ajoute setColor() pour définir la couleur.

Voici l'exemple de code que tu devrais obtenir au final :

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

Conclusion

Félicitations, tu as parcouru ce guide complet sur AWT.Color en Java. Désormais, la manipulation des interfaces sera beaucoup plus facile. N'oublie pas d'appliquer tes connaissances en résolvant des problèmes d'entraînement et des quiz CodeGym. C'est en forgeant qu'on devient forgeron, alors donne le meilleur de toi-même pour résoudre les problèmes types !