Java.Awt.Color क्लास

यदि आप जावा सार टूलकिट में महारत हासिल कर रहे हैं, तो आपको जावा एडब्ल्यूटी कलर क्लास के अनुप्रयोगों को सीखना होगा। चूंकि इसमें बहुत सारे कंस्ट्रक्टर और तरीके शामिल हैं, इसलिए यह पहली बार में डराने वाला लग सकता है। लेकिन चिंता की कोई बात नहीं है, हमने आपको कवर कर लिया है:) जावा एडब्ल्यूटी कलर पर इस पूरी सूची के साथ, आप सीखेंगे कि एक नया रंग प्रकार कैसे बनाएं और इसे तुरंत प्रबंधित करें। हम कुछ अभ्यास परीक्षण भी प्रदान करेंगे जो आपके कौशल को सुधारने में आपकी सहायता करेंगे।

जावा में AWT कलर क्लास क्या है?

एडब्ल्यूटी रंग का प्राथमिक उद्देश्य डेवलपर्स को आरजीबी (लाल, हरा, नीला), आरजीबीए (लाल, हरा, नीला, अल्फा), या एचएसबी (रंग, संतृप्ति, बीआरआई घटक) पैकेज का उपयोग करके जावा कोड का उपयोग करके नए रंग बनाने की अनुमति देना है। वर्ग में दो मान होते हैं - छाया का कोड और अस्पष्टता/पारदर्शिता का मान। Java.Awt.Color क्लास - 1

यहां बताया गया है कि आप क्लास java.awt.Color कैसे घोषित करते हैं:

public class Color
   extends Object
      implements Paint, Serializable

Class.java.awt.Color का उपयोग करके विभिन्न प्रकार के रंगों को घोषित करने के लिए, डेवलपर्स कंस्ट्रक्टर्स का उपयोग करते हैं - हम अब उन पर एक नज़र डालेंगे।

जावा में AWT.Color कंस्ट्रक्टर्स

आपके द्वारा बनाए जाने वाले रंग के पैरामीटर के आधार पर, आपको एक विशिष्ट प्रकार के रंग निर्माता का उपयोग करने की आवश्यकता होगी। इनमें से कुछ मुट्ठी भर हैं - आइए एक-एक करके इनकी जाँच करें।

Color(float r, float g, float b)वह वर्ग है जिसका उपयोग आप आरजीबी रंग योजना में अपारदर्शी रंग को परिभाषित करने के लिए करते हैं। आप 0.0 और 0.1 के बीच कहीं भी रंग सीमा निर्दिष्ट कर सकते हैं।
Color(float r, float b, float g, float a)वह वर्ग है जो आरजीबीए रंग को परिभाषित करता है (उपलब्ध मानों की सीमा 0.0 और 0.1 है)।
Color(ColorSpace c, float[], co, float a)आपके द्वारा पहले निर्दिष्ट ColorSpace में रंग को परिभाषित करता है। एक डेवलपर परिभाषित अल्फा के फ्लोट ऐरे में रंग घटकों की श्रेणी निर्दिष्ट करता है।
Color(int, rgb)आरजीबी रंग (अपारदर्शी) बनाने वाला वर्ग है। कंस्ट्रक्टर के घटक मूल्य पर ध्यान देना सुनिश्चित करें - लाल रंग के लिए 16-23, हरे रंग के लिए 8-15, नीले रंग के लिए 0-7।
Color(int r, int g, int b)- अपारदर्शी आरजीबी रंग को परिभाषित करने के लिए इस्तेमाल की जाने वाली विधि। रंग का मान 0 और 255 के बीच होना चाहिए।
Color(int r, int g, int b, int a)- RGBA स्कीम (0-255) में रंग बनाता है।
Color(int rgba, boolean b)परिभाषित संयुक्त मान के भीतर sRGB रंग बनाने के लिए उपयोग किया जाता है। मानों की सीमा अल्फा के लिए 24-31, लाल के लिए 16-23, हरे के लिए 8-15 और नीले रंग के लिए 0-7 तक है।

इसके अलावा, class.awt.color उन क्षेत्रों से संचालित होता है, जो इनसे विरासत में मिले हैं Java.awt.Transparency:

TRANSLUCENTदर्शाता है कि रंग में अल्फा मान हैं या नहीं और इसके दो मान हैं - 0 और 1।
OPAQUEऑब्जेक्ट को पूर्ण अपारदर्शिता की गारंटी देने के लिए 1 का अल्फा मान असाइन करता है।
BITMASKपूर्ण अपारदर्शिता या पारदर्शिता मूल्य का प्रतिनिधित्व करता है और (0; 1) की सीमा के भीतर स्थित है जहां 0 पूर्ण पारदर्शिता है और 1 अत्यधिक अपारदर्शिता है।

जावा एडब्ल्यूटी कलर क्लास के साथ उपयोग करने के लिए शीर्ष 15 तरीके

एक रंग में हेरफेर करने के लिए, उसके अंधेरे या चमक को समायोजित करने के लिए, जावा डेवलपर्स विभिन्न तरीकों पर भरोसा करते हैं। उनमें से दर्जनों हैं इसलिए आपको उन सभी को कंठस्थ करने की आवश्यकता नहीं है। हालाँकि, जब सबसे व्यापक रूप से उपयोग किए जाने वाले Java AWT रंग विधियों की बात आती है, तो हमने सूची को पंद्रह तक सीमित कर दिया। जावा एपीआई प्रलेखन को संदर्भित किए बिना इन्हें याद रखना डेवलपर्स के लिए मददगार होगा।

गहरा ()

विधि का उपयोग एक नया रंग बनाने के लिए किया जाता है जो आपके द्वारा पहले से परिभाषित रंग का एक गहरा संस्करण है। उदाहरण :

Color.green.darker()

यदि darker()एक बार आवेदन करना आपके लिए आवश्यक छाया बनाने के लिए पर्याप्त नहीं है, तो इस विधि को जितनी बार चाहें उतनी बार फिर से लागू करने के लिए स्वतंत्र महसूस करें, जैसा कि नीचे दिखाया गया है:

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

उज्जवल ()

जैसा कि नाम से पता चलता है, Color brighter()आपके पास पहले से मौजूद शेड को चमकाने के लिए उपयोग किया जाता है। इसी तरह darker(), इसे प्रति एक रंग में कई बार इस्तेमाल किया जा सकता है। उदाहरण :

Color myColor = Color.RED;

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

इंट गेटअल्फा ()

यदि आप अपने रंग के अल्फा घटक को वापस करना चाहते हैं, तो इस विधि का उपयोग करें। ध्यान रखें कि अल्फा मान 0-255 की सीमा के भीतर हैं। यहाँ विधि के अनुप्रयोग और वापसी का उदाहरण दिया गया है। उदाहरण :

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

स्थिर रंग getColor (स्ट्रिंग एनएम)

जावा डेवलपर्स इस पद्धति का उपयोग सिस्टम गुणों का उपयोग करके रंग का पता लगाने के लिए कर सकते हैं। समान उद्देश्यों को संभालने वाली अन्य विधियाँ हैं:

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

स्थिर रंग डिकोड (स्ट्रिंग एनएम)

इस पद्धति का उपयोग रंग को स्ट्रिंग के रूप में प्रदर्शित करने के लिए किया जाता है। रूपांतरण पूरा होने के बाद, एक डेवलपर को एक परिभाषित अपारदर्शी रंग मिलेगा। उदाहरण :

public static Color decodeColor(String hexColor) {

 return Color.decode(hexColor);

पेंटकॉन्टेक्स्ट क्रिएट कॉन्टेक्स्ट (ColorModel cm, Rectangle r, Rectangle2D r2d, AffineTransform xform, RenderingHints संकेत)

यह विधि जटिल दिखती है लेकिन ऐसा लगता है कि इसमें हेरफेर करना आसान है। Paint Context CreateContext()दोहराए गए ठोस रंग पैटर्न को परिभाषित करने के लिए उपयोग किया जाता है। उदाहरण :

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

   }
 }
}

फ्लोट [] गेटकंपोनेंट्स (कलरस्पेस सीस्पेस, फ्लोट [] कॉम्पएरे)

यह एक जावा विधि है जिसे आप रंग पर लागू कर सकते हैं ताकि इसकी फ्लोट सरणी और अल्फा घटकों को वापस कर सकें। विधि ColorSpacecspace द्वारा परिभाषित दिए गए पर लागू होती है। उदाहरण :

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

return myColor.getComponents(cspace, compArray);

}

कलरस्पेस getColorSpace()

जावा डेवलपर्स इस विधि का उपयोग चुने हुए रंग के लिए रंग स्थान वापस करने के लिए कर सकते हैं। दी गई प्रविष्टि के लिए रंग स्थान प्राप्त करने का दूसरा तरीका Arrays.to.String को लागू करना है। यह एक अधिक जटिल कार्यनीति है, जैसा कि नीचे दिए गए उदाहरण में देखा गया है: उदाहरण :

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 (फ्लोट एच, फ्लोट एस, फ्लोट बी)

जावा डेवलपर्स एचएसबी मॉडल के मूल्यों के आधार पर एक नया रंग वस्तु बनाने के लिए इस पद्धति को लागू करते हैं। उदाहरण :

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.

गेटग्रीन ()

यह जावा विधि आपके द्वारा बनाए गए रंग के लिए हरे रंग के घटक का मान लौटाती है। आरजीबी रंग योजना में हरे रंग के अनुरूप रेंज के भीतर सभी मान फिट होते हैं। उदाहरण :

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

लाल ले लो()

इसी प्रकार getGreen(), getRedकिसी दिए गए रंग के लाल घटक के लिए मान लौटाता है। ऊपर दिए गए उदाहरण में आप देख चुके हैं कि यह तरीका कैसे लागू किया गया था।

गेटब्लू ()

यह विधि आरजीबी रंग योजना के मूल्यों की सीमा के भीतर नीले रंग का मान लौटाती है। इसी तरह, उपयोग करने के उदाहरण के लिए getBlue(), का विवरण देखें getGreen()।

गेटअल्फा ()

GetAlpha() विधि का उपयोग जावा में तब किया जाता है जब कोई डेवलपर किसी दिए गए रंग का अल्फा मान खोजना चाहता है। इसी तरह आरबीजी के लिए, सभी रंगों के अल्फाज 0-255 रेंज के भीतर हैं। उदाहरण : यहां बताया गया है कि getAlpha()लूप के हिस्से के रूप में इसका उपयोग कैसे किया गया।

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

ट्रांसपेरेंसी प्राप्त करें ()

यह विधि उस पारदर्शिता मान को लौटाती है जिसे आपने या किसी अन्य डेवलपर ने इसे बनाते समय रंग के लिए निर्दिष्ट किया था। उदाहरण :

public int getTransparency() {

return myColor.getTransparency();

बूलियन बराबर (ऑब्जेक्ट ओब्ज)

यदि आप दो रंगों की एक दूसरे से तुलना कर रहे हैं तो यह विधि अत्यधिक उपयोगी है। यह जावा डेवलपर्स को यह जानने देता है कि दो रंगीन वस्तुओं के बराबर मूल्य हैं या नहीं। उदाहरण :

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

बराबर (ऑब्जेक्ट ओब्ज)

इसी तरह boolean equals(Object obj), यह एक तुलनात्मक पद्धति है। हम इसका उपयोग यह निर्धारित करने के लिए करते हैं कि रंगीन वस्तुएं एक दूसरे के बराबर हैं या नहीं। उदाहरण :

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

जावा में प्रयुक्त मुख्य रंगों की मार्गदर्शिका

अब जब आप जावा में रंगों में हेरफेर करने के लिए उपयोग की जाने वाली विधियों की समझ रखते हैं, तो आइए उन फ़ील्ड प्रकारों पर नज़र डालें जिनके साथ आप काम करेंगे। ये वास्तविक स्थिर रंग हैं जिन्हें जावा डेवलपर्स परिभाषित कर सकते हैं। आप या तो किसी रंग को उसका नाम दर्ज करके परिभाषित कर सकते हैं (सुनिश्चित करें कि आपने इसे ठीक उसी तरह से दर्ज किया है जिस तरह से यह आधिकारिक दस्तावेज में लिखा गया है) या इसके आरजीबी मान को निर्दिष्ट करें। आइए डेवलपर्स द्वारा उपयोग किए जाने वाले पैलेट पर एक नज़र डालें:

कार्यक्षेत्र नाम	विवरण
स्थिर रंग काला (काला)	काले रंग को परिभाषित करता है
स्थिर रंग सफेद (सफेद)	सफेद रंग को परिभाषित करता है
स्थिर रंग नीला (नीला)	नीले रंग को परिभाषित करते थे
स्थिर रंग ग्रे (ग्रे)	ग्रे रंग को परिभाषित करता है
स्थिर रंग गहरा स्लेटी (DARK_GRAY)	भूरे रंग की एक गहरी छाया को परिभाषित करता है
स्थिर रंग हल्का स्लेटी (LIGHT_GRAY)	ग्रे के हल्के शेड को परिभाषित करता है
स्थिर रंग हरा (हरा)	हरे रंग को परिभाषित करने के लिए प्रयोग किया जाता है
स्थिर रंग मैजेंटा (मैजेंटा)	मैजेंटा शेड को परिभाषित करता है
स्थिर रंग गुलाबी (गुलाबी)	जावा में गुलाबी परिभाषित करता है
स्थिर रंग नारंगी (नारंगी)	जावा में नारंगी रंग बनाता है
स्थिर रंग पीला (पीला)	पीले रंग को परिभाषित करते थे
स्थिर रंग लाल (लाल)	जावा में लाल रंग को परिभाषित करता है

जावा में AWT.Color का उपयोग करने के लिए अभ्यास समस्याएँ

क्या आपको ऐसा लगता है कि आपके पास जावा में AWT कलर की ठोस नींव है? आइए कुछ व्यावहारिक समस्याओं को हल करके इन कौशलों का परीक्षण करें - यहां, आपको कंस्ट्रक्टर और सामान्य तरीकों के साथ-साथ अन्य गैर-रंग-संबंधित जावा टूल लागू करने होंगे। अभ्यास समस्या # 1 । एक कस्टम घटक बनाएँ जो एक प्रोग्राम उपयोगकर्ता को आरजीबी स्तरों को एक रंग में बदलने देता है (के समान RGBColorChooser)। अपने घटकों में getColor() शामिल करना सुनिश्चित करें। घटक को पैनल उपवर्ग बनाएं, एप्लेट नहीं। उत्तर : यह काफी जटिल समस्या है - आइए इसे प्रबंधनीय चरणों में विभाजित करें:

एक को RGBChooserएक घटक में परिवर्तित करें।
घटक में एक नया रूटीन जोड़ें - getColor().
setColor()रंग सेट करने के लिए जोड़ें ।

यहां नमूना कोड है जो आपको दिन के अंत में मिलना चाहिए:

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

निष्कर्ष

बधाई हो, आप जावा में AWT.Color पर इस व्यापक गाइड के माध्यम से प्राप्त कर चुके हैं। अब, इंटरफेस को संभालना बहुत आसान हो जाएगा। अभ्यास समस्याओं और CodeGym क्विज़ को हल करके अपने ज्ञान का प्रयोग करना न भूलें। अभ्यास परिपूर्ण बनाता है इसलिए नमूना समस्याओं को अपना सर्वश्रेष्ठ शॉट दें!