Java.Awt.Color Class

אם אתה שולט ב-Java Abstract Toolkit, תצטרך ללמוד את היישומים של Java AWT Color Class. מכיוון שיש הרבה בנאים ושיטות מעורבים, זה עשוי להרגיש מאיים בהתחלה. אבל אל דאגה, סיקרנו אותך :) עם הסקירה המלאה הזו על Java AWT Color, תלמד כיצד ליצור סוג צבע חדש ולנהל אותו תוך זמן קצר. אנו נציע גם כמה מבחני תרגול שיעזרו לך לחדד את המיומנות שלך.

מה זה AWT Color Class ב-Java?

המטרה העיקרית של AWT Color היא לאפשר למפתחים ליצור צבעים חדשים באמצעות קוד Java באמצעות חבילות RGB (אדום, ירוק, כחול), RGBA (אדום, ירוק, כחול, אלפא), או HSB (גוון, רוויה, רכיבי BRI). המחלקה מכילה שני ערכים - הקוד של הגוון וערך האטימות/שקיפות. כך אתה מכריז על Class java.awt.Color:

public class Color
   extends Object
      implements Paint, Serializable

כדי להכריז על סוגים שונים של צבעים באמצעות Class.java.awt.Color, מפתחים משתמשים בבנאים - נסתכל עליהם כעת.

AWT.Color Constructors ב-Java

בהתאם לפרמטר של הצבע שברצונך ליצור, תצטרך להשתמש בסוג מסוים של בנאי צבע. יש קומץ כאלה - בואו נבחן אותם אחד אחד.

• Color(float r, float g, float b)הוא המחלקה שבה אתה משתמש כדי להגדיר צבע בערכת הצבעים RGB שהוא אטום. אתה יכול לציין את טווח הצבעים בכל מקום בין 0.0 ל-0.1.
• Color(float r, float b, float g, float a)הוא המחלקה שמגדירה צבע RGBA (טווח הערכים הזמינים הוא 0.0 ו-0.1).
• Color(ColorSpace c, float[], co, float a)מגדיר צבע ב-ColorSpace שאתה מציין מראש. מפתח מציין את טווח רכיבי הצבע במערך הצף של אלפא מוגדר.
• Color(int, rgb)הוא מחלקה שיוצרת צבע RGB (אטום). הקפידו לשים לב לערך הרכיב של הבנאי - 16-23 לאדום, 8-15 לירוק, 0-7 לכחול.
• Color(int r, int g, int b)- שיטה המשמשת להגדרת צבע RGB אטום. ערך הצבע צריך להיות בין 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 Class

כדי לתפעל צבע, להתאים את הכהות או הבהירות שלו, מפתחי Java מסתמכים על שיטות שונות. יש עשרות כאלה אז אתה לא צריך ללמוד את כולם בעל פה. עם זאת, כשמדובר בשיטות ה-Java AWT Color הנפוצות ביותר, צמצמנו את הרשימה לחמש עשרה. לזכור אותם מבלי להתייחס לתיעוד Java API יהיה מועיל למפתחים.

כהה()

השיטה משמשת ליצירת צבע חדש שהוא גרסה כהה יותר של הצבע שכבר הגדרת. דוגמא :

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

int getAlpha()

אם ברצונך להחזיר את רכיב האלפא של הצבע שלך, השתמש בשיטה זו. זכור כי ערכי אלפא נמצאים בטווח 0-255. הנה הדוגמה ליישום והחזרה של השיטה. דוגמא :

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

צבע סטטי getColor(מחרוזת ננומטר)

מפתחי Java יכולים להשתמש בשיטה זו כדי לאתר צבע באמצעות מאפייני מערכת. ישנן שיטות אחרות המטפלות ביעדים דומים:

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

פענוח צבע סטטי (מחרוזת ננומטר)

שיטה זו משמשת להציג צבע כמחרוזת. לאחר השלמת ההמרה, מפתח יקבל צבע אטום מוגדר. דוגמא :

public static Color decodeColor(String hexColor) {

 return Color.decode(hexColor);

PaintContext createContext(ColorModel cm, Rectangle r, Rectangle2D r2d, AffineTransform xform, רמזים לעיבוד רמזים)

שיטה זו נראית מורכבת אך קלה יותר לתפעל אותה ממה שהיא נראית. 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);

   }
 }
}

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

זוהי שיטת Java שאתה יכול להחיל על צבע כדי להחזיר את מערך הצוף ורכיבי האלפא שלו. השיטה חלה על נתון ColorSpaceהמוגדר על ידי cspace. דוגמא :

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

return myColor.getComponents(cspace, compArray);

}

ColorSpace getColorSpace()

מפתחי Java יכולים להשתמש בשיטה זו כדי להחזיר את מרחב הצבעים עבור צבע שנבחר. דרך נוספת לקבל מרחב צבע עבור ערך נתון היא על ידי החלת 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(float h, float s, float b)

מפתחי Java מיישמים שיטה זו כדי ליצור אובייקט צבעוני חדש המבוסס על הערכים של מודל HSB. דוגמא :

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

שיטת Java זו מחזירה את הערך של הרכיב הירוק עבור הצבע שיצרת. כל הערכים מתאימים לטווח המתאים לירוק בערכת הצבעים RGB. דוגמא :

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

getRed()

בדומה ל getGreen(), getRedמחזירה את הערך עבור הרכיב האדום של צבע נתון. כבר ראית איך השיטה יושמה בדוגמה למעלה.

getBlue()

שיטה זו מחזירה את הערך של כחול בטווח הערכים של ערכת הצבעים RGB. כמו כן, לדוגמא של שימוש getBlue(), ראה את התיאור של getGreen().

getAlpha()

שיטת getAlpha() משמשת ב-Java כאשר מפתח רוצה למצוא את ערך האלפא של צבע נתון. בדומה ל-RBG, האלפא של כל הצבעים נמצא בטווח 0-255. דוגמה : כך getAlpha()נעשה שימוש כחלק מלולאה.

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

getTransparency()

שיטה זו מחזירה את ערך השקיפות שאתה או מפתח אחר שציינת עבור הצבע בעת יצירתו. דוגמא :

public int getTransparency() {

return myColor.getTransparency();

בוליאני שווה (Object obj)

שיטה זו שימושית מאוד אם אתה משווה שני צבעים זה לזה. זה מאפשר למפתחי Java לדעת אם לשני אובייקטים צבעוניים יש ערכים שווים. דוגמא :

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

שווה (Object obj)

בדומה ל boolean equals(Object obj), זו היא שיטה השוואתית. אנו משתמשים בו כדי לקבוע אם אובייקטים צבעוניים שווים זה לזה. דוגמא :

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

מדריך לצבעים עיקריים בשימוש ב-Java

כעת, לאחר שהבנתם את השיטות המשמשות לעיבוד צבעים ב-Java, בואו נסתכל על סוגי השדות איתם תעבדו. אלו הם הצבעים הסטטיים בפועל שמפתחי Java יכולים להגדיר. אתה יכול להגדיר צבע על ידי הזנת שמו (וודא שאתה מזין אותו בדיוק כמו שהוא כתוב בתיעוד הרשמי) או ציון ערך ה-RGB שלו. בואו נסתכל על הפלטה שבה משתמשים מפתחי הצבעים:

תרגול בעיות לשימוש ב-AWT.Color ב-Java

האם אתה מרגיש שיש לך בסיס מוצק של AWT Color ב-Java? הבה נבחן את המיומנויות הללו על ידי פתרון כמה בעיות מעשיות - כאן, תצטרך ליישם בנאים ושיטות נפוצות, כמו גם כלי Java אחרים שאינם קשורים לצבע. תרגול בעיה מס' 1 . צור רכיב מותאם אישית המאפשר למשתמש בתוכנית לכוונן רמות RGB בצבע (בדומה ל RGBColorChooser). הקפד לכלול את getColor() ברכיבים שלך. הפוך את הרכיב לתת-מחלקת פאנל, לא יישומון. תשובה : זו בעיה מורכבת למדי - בואו נחלק אותה לשלבים ניתנים לניהול:

1. המר את RGBChooserה- לרכיב.
2. הוסף שגרה חדשה לרכיב - getColor().
3. הוסף 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 ב-Java. כעת, הטיפול בממשקים יהיה הרבה יותר קל. אל תשכח ליישם את הידע שלך על ידי פתרון בעיות תרגול וחידוני CodeGym. תרגול עושה מושלם אז תן את ההזדמנות הטובה ביותר לבעיות לדוגמה!