Java.Awt.Color Class

Kung pinagkadalubhasaan mo ang Java Abstract Toolkit, kakailanganin mong matutunan ang mga aplikasyon ng Java AWT Color Class. Dahil maraming mga konstruktor at pamamaraan na kasangkot, maaari itong makaramdam ng pananakot sa simula. Ngunit huwag mag-alala, sinaklaw ka namin:) Sa buong rundown na ito sa Java AWT Color, matututunan mo kung paano lumikha ng bagong uri ng kulay at pamahalaan ito sa lalong madaling panahon. Mag-aalok din kami ng ilang mga pagsusulit sa pagsasanay na makakatulong sa iyo na mahasa ang iyong kakayahan.

Ano ang AWT Color Class sa Java?

Ang pangunahing layunin ng AWT Color ay payagan ang mga developer na lumikha ng mga bagong kulay gamit ang Java code gamit ang RGB (pula, berde, asul), RGBA (pula, berde, asul, alpha), o HSB (kulay, saturation, mga bahagi ng BRI) na mga pakete. Ang klase ay naglalaman ng dalawang value - ang code ng shade at ang value ng opacity/transparency. Narito kung paano mo idedeklara ang Class java.awt.Color:

public class Color
   extends Object
      implements Paint, Serializable

Upang magdeklara ng iba't ibang uri ng mga kulay gamit ang Class.java.awt.Color, gumagamit ang mga developer ng mga constructor - titingnan natin ang mga ito ngayon.

AWT.Color Constructors sa Java

Depende sa parameter ng kulay na gusto mong gawin, kakailanganin mong gumamit ng partikular na uri ng color constructor. Mayroong isang dakot ng mga ito - suriin natin ang mga ito nang paisa-isa.

• Color(float r, float g, float b)ay ang klase na iyong ginagamit upang tukuyin ang isang kulay sa RGB color scheme na opaque. Maaari mong tukuyin ang hanay ng kulay kahit saan sa pagitan ng 0.0 at 0.1.
• Color(float r, float b, float g, float a)ay ang klase na tumutukoy sa isang kulay ng RGBA (ang hanay ng mga magagamit na halaga ay 0.0 at 0.1).
• Color(ColorSpace c, float[], co, float a)ay tumutukoy sa isang kulay sa ColorSpace na iyong tinukoy muna. Tinutukoy ng isang developer ang hanay ng mga bahagi ng kulay sa float array ng isang tinukoy na alpha.
• Color(int, rgb)ay isang klase na lumilikha ng isang RGB na kulay (opaque). Siguraduhing bigyang-pansin ang component value ng constructor - 16-23 para sa pula, 8-15 para sa berde, 0-7 para sa asul.
• Color(int r, int g, int b)- isang paraan na ginamit upang tukuyin ang isang opaque na kulay ng RGB. Ang halaga ng kulay ay dapat nasa pagitan ng 0 at 255.
• Color(int r, int g, int b, int a)- lumilikha ng isang kulay sa RGBA scheme (0-255).
• Color(int rgba, boolean b)ay ginagamit upang lumikha ng mga kulay ng sRGB sa loob ng tinukoy na pinagsamang halaga. Ang hanay ng mga halaga ay sumasaklaw sa 24-31 para sa alpha, 16-23 para sa pula, 8-15 para sa berde, at 0-7 para sa asul.

Maliban doon, gumagana ang class.awt.color kasama ang mga field, na minana mula sa Java.awt.Transparency:

• TRANSLUCENTkumakatawan sa kung ang kulay ay naglalaman ng mga alpha value at may dalawang value - 0 at 1.
• OPAQUEnagtatalaga ng alpha value na 1 sa object na ginagarantiyahan itong kumpletong opaqueness.
• BITMASKkumakatawan sa ganap na opaqueness o transparency na halaga at nasa loob ng hanay ng (0;1) kung saan ang 0 ay ganap na transparency at ang 1 ay matinding opaqueness.

Nangungunang 15 Paraan na Gagamitin Sa Java AWT Color Class

Upang manipulahin ang isang kulay, ayusin ang kadiliman o liwanag nito, umaasa ang mga developer ng Java sa iba't ibang pamamaraan. Mayroong dose-dosenang mga iyon kaya hindi mo na kailangang matutunan ang lahat ng ito sa pamamagitan ng puso. Gayunpaman, pagdating sa pinakamalawak na ginagamit na mga pamamaraan ng Kulay ng Java AWT, pinaliit namin ang listahan hanggang labinlimang. Ang pag-alala sa mga ito nang hindi kinakailangang sumangguni sa dokumentasyon ng Java API ay makakatulong sa mga developer.

darker()

Ginagamit ang paraan upang lumikha ng bagong kulay na mas madilim na bersyon ng kulay na natukoy mo na. Halimbawa :

Color.green.darker()

Kung ang pag-apply darker()nang isang beses ay hindi sapat upang lumikha ng isang shade na kailangan mo, huwag mag-atubiling ilapat muli ang pamamaraan nang maraming beses hangga't gusto mo, tulad ng ipinapakita sa ibaba:

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

mas maliwanag()

Gaya ng ipinahihiwatig ng pangalan, Color brighter()ay ginagamit upang pasayahin ang lilim na mayroon ka na. Katulad ng darker(), maaari itong magamit nang maraming beses bawat solong kulay. Halimbawa :

Color myColor = Color.RED;          

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

int getAlpha()

Kung gusto mong ibalik ang alpha component ng iyong kulay, gamitin ang paraang ito. Tandaan na ang mga alpha value ay nasa loob ng 0-255 range. Narito ang halimbawa ng aplikasyon at pagbabalik ng pamamaraan. Halimbawa :

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

static na Kulay getColor(String nm)

Maaaring gamitin ng mga developer ng Java ang paraang ito upang mahanap ang isang kulay gamit ang mga katangian ng system. Mayroong iba pang mga pamamaraan sa paghawak ng mga katulad na layunin:

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

static na Color decode (string nm)

Ang pamamaraang ito ay ginagamit ipakita ang isang kulay bilang isang string. Pagkatapos makumpleto ang conversion, ang isang developer ay makakakuha ng tinukoy na opaque na kulay. Halimbawa :

public static Color decodeColor(String hexColor) {

 return Color.decode(hexColor);

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

Mukhang kumplikado ang pamamaraang ito ngunit mas madaling manipulahin kaysa sa tila. Paint Context CreateContext()ay ginagamit upang tukuyin ang isang paulit-ulit na solidong pattern ng kulay. Halimbawa :

 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)

Ito ay isang Java method na maaari mong ilapat sa isang kulay upang ibalik ang float array at alpha na mga bahagi nito. Nalalapat ang pamamaraan sa isang ibinigay ColorSpacena tinukoy ng cspace. Halimbawa :

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

return myColor.getComponents(cspace, compArray);

}

ColorSpace getColorSpace()

Maaaring gamitin ng mga developer ng Java ang pamamaraang ito upang ibalik ang espasyo ng kulay para sa napiling kulay. Ang isa pang paraan para makakuha ng color space para sa isang naibigay na entry ay sa pamamagitan ng paglalapat ng Arrays.to.String. Ito ay isang mas kumplikadong diskarte, tulad ng makikita sa halimbawa sa ibaba: Mga Halimbawa :

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)

Inilapat ng mga developer ng Java ang pamamaraang ito upang lumikha ng isang bagong bagay na may kulay batay sa mga halaga ng modelong HSB. Halimbawa :

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

Ibinabalik ng Java method na ito ang value ng green component para sa kulay na iyong ginawa. Ang lahat ng mga halaga ay magkasya sa loob ng hanay na tumutugma sa berde sa scheme ng kulay ng RGB. Halimbawa :

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

getRed()

Katulad ng getGreen(), getRedibinabalik ang halaga para sa pulang bahagi ng isang ibinigay na kulay. Nakita mo na kung paano inilapat ang pamamaraan sa halimbawa sa itaas.

getBlue()

Ibinabalik ng pamamaraang ito ang halaga ng asul sa loob ng hanay ng mga halaga ng scheme ng kulay ng RGB. Gayundin, para sa halimbawa ng paggamit ng getBlue(), tingnan ang paglalarawan ng getGreen().

getAlpha()

Ang getAlpha() method ay ginagamit sa Java kapag gusto ng developer na mahanap ang alpha value ng isang partikular na kulay. Katulad ng RBG, ang mga alpha ng lahat ng kulay ay nasa loob ng 0-255 na hanay. Halimbawa : narito kung paano getAlpha()ginamit bilang bahagi ng isang loop.

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

getTransparency()

Ibinabalik ng pamamaraang ito ang halaga ng transparency na tinukoy mo o ng isa pang developer para sa kulay kapag ginagawa ito. Halimbawa :

public int getTransparency() {

return myColor.getTransparency();

boolean equals(Object obj)

Ang pamamaraang ito ay lubos na kapaki-pakinabang kung ikaw ay naghahambing ng dalawang kulay sa isa't isa. Nagbibigay-daan ito sa mga developer ng Java na malaman kung ang dalawang bagay na may kulay ay may pantay na halaga. Halimbawa :

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));
  }
}

katumbas ng(Object obj)

Katulad ng boolean equals(Object obj), ang isang ito ay isang comparative method. Ginagamit namin ito upang matukoy kung ang mga bagay na may kulay ay katumbas ng bawat isa. Halimbawa :

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

Gabay sa Mga Pangunahing Kulay na Ginamit sa Java

Ngayon na mayroon ka nang pag-unawa sa mga pamamaraan na ginagamit upang manipulahin ang mga kulay sa Java, tingnan natin ang mga uri ng field na iyong gagawin. Ito ang mga aktwal na static na kulay na maaaring tukuyin ng mga developer ng Java. Maaari mong tukuyin ang isang kulay sa pamamagitan ng paglalagay ng pangalan nito (siguraduhing ipasok mo ito nang eksakto sa paraan ng pagkakasulat nito sa opisyal na dokumentasyon) o pagtukoy sa halaga ng RGB nito. Tingnan natin ang ginagamit ng mga developer ng palette:

Mga Problema sa Pagsasanay Para sa Paggamit ng AWT.Color sa Java

Nararamdaman mo ba na mayroon kang matibay na pundasyon ng AWT Color sa Java? Subukan natin ang mga kasanayang ito sa pamamagitan ng paglutas ng ilang praktikal na problema - dito, kakailanganin mong maglapat ng mga constructor at karaniwang pamamaraan, pati na rin ang iba pang mga tool sa Java na hindi nauugnay sa kulay. Practice problema #1 . Gumawa ng custom na component na nagbibigay-daan sa user ng program na mag-tweak ng mga antas ng RGB sa isang kulay (katulad ng RGBColorChooser). Tiyaking isama ang getColor() sa iyong mga bahagi. Gawing subclass ng Panel ang bahagi, hindi isang applet. Sagot : ito ay isang medyo kumplikadong problema - hatiin natin ito sa mga mapapamahalaang hakbang:

1. I-convert ang isang RGBChoosersa isang bahagi.
2. Magdagdag ng bagong routine sa component - getColor().
3. Idagdag setColor()para itakda ang kulay.

Narito ang sample code na dapat mong makuha sa pagtatapos ng araw:

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

Konklusyon

Binabati kita, nalampasan mo ang malawak na gabay na ito sa AWT.Color sa Java. Ngayon, magiging mas madali ang paghawak ng mga interface. Huwag kalimutang ilapat ang iyong kaalaman sa pamamagitan ng paglutas ng mga problema sa pagsasanay at mga pagsusulit sa CodeGym. Ang pagsasanay ay nagiging perpekto kaya bigyan ang mga sample na problema sa iyong pinakamahusay na pagbaril!