Classe Java.Awt.Color

Se stai padroneggiando Java Abstract Toolkit, dovrai imparare le applicazioni di Java AWT Color Class. Poiché sono coinvolti molti costruttori e metodi, all'inizio potrebbe sembrare intimidatorio. Ma non preoccuparti, ti abbiamo coperto :) Con questo riepilogo completo su Java AWT Color, imparerai come creare un nuovo tipo di colore e gestirlo in pochissimo tempo. Offriremo anche un paio di test pratici che ti aiuteranno ad affinare le tue abilità.

Che cos'è la classe di colore AWT in Java?

Lo scopo principale di AWT Color è consentire agli sviluppatori di creare nuovi colori utilizzando il codice Java utilizzando pacchetti RGB (rosso, verde, blu), RGBA (rosso, verde, blu, alfa) o HSB (tonalità, saturazione, componenti BRI). La classe contiene due valori: il codice della sfumatura e il valore di opacità/trasparenza. Ecco come dichiarare Class java.awt.Color:

public class Color
   extends Object
      implements Paint, Serializable

Per dichiarare diversi tipi di colori usando Class.java.awt.Color, gli sviluppatori usano i costruttori: li esamineremo ora.

Costruttori AWT.Color in Java

A seconda del parametro del colore che desideri creare, dovrai utilizzare un tipo specifico di costruttore di colori. Ce n'è una manciata - esaminiamoli uno per uno.

• Color(float r, float g, float b)è la classe utilizzata per definire un colore opaco nello schema di colori RGB. È possibile specificare l'intervallo di colori ovunque tra 0,0 e 0,1.
• Color(float r, float b, float g, float a)è la classe che definisce un colore RGBA (l'intervallo di valori disponibili è 0.0 e 0.1).
• Color(ColorSpace c, float[], co, float a)definisce un colore nel ColorSpace specificato in precedenza. Uno sviluppatore specifica l'intervallo di componenti di colore nell'array float di un alfa definito.
• Color(int, rgb)è una classe che crea un colore RGB (opaco). Assicurati di prestare attenzione al valore del componente del costruttore: 16-23 per il rosso, 8-15 per il verde, 0-7 per il blu.
• Color(int r, int g, int b)- un metodo utilizzato per definire un colore RGB opaco. Il valore del colore deve essere compreso tra 0 e 255.
• Color(int r, int g, int b, int a)- crea un colore nello schema RGBA (0-255).
• Color(int rgba, boolean b)viene utilizzato per creare colori sRGB all'interno di un valore combinato definito. L'intervallo di valori va da 24 a 31 per l'alfa, da 16 a 23 per il rosso, da 8 a 15 per il verde e da 0 a 7 per il blu.

Oltre a questo, class.awt.color opera con i campi, ereditati da Java.awt.Transparency:

• TRANSLUCENTrappresenta se il colore contiene o meno valori alfa e ha due valori: 0 e 1.
• OPAQUEassegna all'oggetto il valore alpha 1 garantendone la completa opacità.
• BITMASKrappresenta il valore assoluto di opacità o trasparenza e si trova all'interno dell'intervallo di (0;1) dove 0 è piena trasparenza e 1 è estrema opacità.

I 15 migliori metodi da utilizzare con Java AWT Color Class

Per manipolare un colore, regolarne l'oscurità o la luminosità, gli sviluppatori Java si affidano a metodi diversi. Ce ne sono dozzine, quindi non devi impararle tutte a memoria. Tuttavia, quando si tratta dei metodi Java AWT Color più utilizzati, abbiamo ristretto l'elenco a quindici. Ricordarli senza dover fare riferimento alla documentazione dell'API Java sarebbe utile per gli sviluppatori.

più scuro()

Il metodo viene utilizzato per creare un nuovo colore che è una versione più scura del colore che hai già definito. Esempio :

Color.green.darker()

Se applicare darker()una volta non è sufficiente per creare una sfumatura di cui hai bisogno, sentiti libero di riapplicare il metodo tutte le volte che vuoi, come mostrato di seguito:

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

più luminoso()

Come suggerisce il nome, Color brighter()viene utilizzato per ravvivare l'ombra che hai già. Analogamente a darker(), potrebbe essere utilizzato più volte per singolo colore. Esempio :

Color myColor = Color.RED;          

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

int getAlpha()

Se vuoi restituire il componente alfa del tuo colore, usa questo metodo. Tieni presente che i valori alfa sono compresi nell'intervallo 0-255. Ecco l'esempio dell'applicazione e del ritorno del metodo. Esempio :

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

Colore statico getColor(Stringa nm)

Gli sviluppatori Java possono utilizzare questo metodo per individuare un colore utilizzando le proprietà di sistema. Esistono altri metodi che gestiscono obiettivi simili:

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

decodifica colore statico (stringa nm)

Questo metodo viene utilizzato per visualizzare un colore come una stringa. Al termine della conversione, uno sviluppatore otterrà un colore opaco definito. Esempio :

public static Color decodeColor(String hexColor) {

 return Color.decode(hexColor);

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

Questo metodo sembra complesso ma è più facile da manipolare di quanto sembri. Paint Context CreateContext()viene utilizzato per definire un motivo a tinta unita ripetuto. Esempio :

 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(SpazioColore cspace, float[] compArray)

Questo è un metodo Java che puoi applicare a un colore per restituire il suo array float e i componenti alfa. Il metodo si applica a un dato ColorSpacedefinito da cspace. Esempio :

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

return myColor.getComponents(cspace, compArray);

}

SpazioColore getSpazioColore()

Gli sviluppatori Java possono utilizzare questo metodo per restituire lo spazio colore per un colore scelto. Un altro modo per ottenere uno spazio colore per una data voce consiste nell'applicare Arrays.to.String. Questa è una strategia più complessa, come mostrato nell'esempio seguente: Esempi :

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)

Gli sviluppatori Java applicano questo metodo per creare un nuovo oggetto colore basato sui valori del modello HSB. Esempio :

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

Questo metodo Java restituisce il valore del componente verde per il colore che hai creato. Tutti i valori rientrano nell'intervallo che corrisponde al verde nella combinazione di colori RGB. Esempio :

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

getRosso()

Analogamente a getGreen(), getRedrestituisce il valore per il componente rosso di un dato colore. Hai già visto come è stato applicato il metodo nell'esempio sopra.

getBlue()

Questo metodo restituisce il valore del blu all'interno dell'intervallo di valori della combinazione di colori RGB. Allo stesso modo, per l'esempio dell'utilizzo di getBlue(), vedere la descrizione di getGreen().

getAlpha()

Il metodo getAlpha() viene utilizzato in Java quando uno sviluppatore desidera trovare il valore alfa di un dato colore. Analogamente a RBG, gli alfa di tutti i colori si trovano nell'intervallo 0-255. Esempio : ecco come getAlpha()è stato utilizzato come parte di un loop.

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

getTrasparenza()

Questo metodo restituisce il valore di trasparenza che tu o un altro sviluppatore avete specificato per il colore durante la creazione. Esempio :

public int getTransparency() {

return myColor.getTransparency();

boolean equals(Oggetto obj)

Questo metodo è molto utile se stai confrontando due colori tra loro. Consente agli sviluppatori Java di sapere se due oggetti di colore hanno valori uguali. Esempio :

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

Analogamente a boolean equals(Object obj), questo è un metodo comparativo. Lo usiamo per determinare se gli oggetti colorati sono uguali tra loro. Esempio :

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

Guida ai colori principali utilizzati in Java

Ora che hai una comprensione dei metodi usati per manipolare i colori in Java, diamo un'occhiata ai tipi di campo con cui lavorerai. Questi sono i colori statici effettivi che gli sviluppatori Java possono definire. Puoi definire un colore inserendone il nome (assicurati di inserirlo esattamente nel modo in cui è scritto nella documentazione ufficiale) o specificando il suo valore RGB. Diamo un'occhiata alla tavolozza utilizzata dagli sviluppatori:

Problemi pratici per l'utilizzo di AWT.Color in Java

Pensi di avere una solida base di AWT Color in Java? Testiamo queste abilità risolvendo alcuni problemi pratici: qui dovrai applicare costruttori e metodi comuni, nonché altri strumenti Java non correlati al colore. Esercitati con il problema n. 1 . Crea un componente personalizzato che consenta a un utente del programma di modificare i livelli RGB in un colore (simile a RGBColorChooser). Assicurati di includere getColor() nei tuoi componenti. Rendi il componente una sottoclasse del Pannello, non un'applet. Risposta : questo è un problema abbastanza complesso - scomponiamolo in passaggi gestibili:

1. Converti un RGBChooserin un componente.
2. Aggiungi una nuova routine al componente - getColor().
3. Aggiungi setColor()per impostare il colore.

Ecco il codice di esempio che dovresti ottenere alla fine della giornata:

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

Conclusione

Congratulazioni, hai letto questa guida completa su AWT.Color in Java. Ora, la gestione delle interfacce sarà molto più semplice. Non dimenticare di applicare le tue conoscenze risolvendo problemi pratici e quiz di CodeGym. La pratica rende perfetti, quindi dai ai problemi del campione il tuo colpo migliore!