CodeGym /Java Blog /சீரற்ற /Java.Awt.வண்ண வகுப்பு
John Squirrels
நிலை 41
San Francisco

Java.Awt.வண்ண வகுப்பு

சீரற்ற குழுவில் வெளியிடப்பட்டது
நீங்கள் ஜாவா சுருக்க கருவித்தொகுப்பில் தேர்ச்சி பெற்றிருந்தால், ஜாவா AWT வண்ண வகுப்பின் பயன்பாடுகளைக் கற்றுக்கொள்ள வேண்டும். இதில் நிறைய கட்டமைப்பாளர்கள் மற்றும் முறைகள் இருப்பதால், முதலில் அது பயமுறுத்துவதாக உணரலாம். ஆனால் கவலை இல்லை, நாங்கள் உங்களுக்கு பாதுகாப்பு அளித்துள்ளோம் :) Java AWT கலரில் இந்த முழு தீர்வறிக்கையின் மூலம், புதிய வண்ண வகையை எவ்வாறு உருவாக்குவது மற்றும் எந்த நேரத்திலும் அதை நிர்வகிப்பது எப்படி என்பதை நீங்கள் கற்றுக் கொள்வீர்கள். உங்கள் திறமையை மேம்படுத்த உதவும் இரண்டு பயிற்சி சோதனைகளையும் நாங்கள் வழங்குவோம்.

ஜாவாவில் AWT கலர் கிளாஸ் என்றால் என்ன?

AWT கலரின் முதன்மை நோக்கம், RGB (சிவப்பு, பச்சை, நீலம்), RGBA (சிவப்பு, பச்சை, நீலம், ஆல்பா) அல்லது HSB (சாயல், செறிவு, BRI கூறுகள்) தொகுப்புகளைப் பயன்படுத்தி ஜாவா குறியீட்டைப் பயன்படுத்தி புதிய வண்ணங்களை உருவாக்க டெவலப்பர்களை அனுமதிப்பதாகும். வகுப்பில் இரண்டு மதிப்புகள் உள்ளன - நிழலின் குறியீடு மற்றும் ஒளிபுகா/வெளிப்படைத்தன்மையின் மதிப்பு. Java.Awt.வண்ண வகுப்பு - 1வகுப்பு java.awt.Color ஐ எவ்வாறு அறிவிக்கிறீர்கள் என்பது இங்கே:
public class Color
   extends Object
      implements Paint, Serializable
Class.java.awt.Color ஐப் பயன்படுத்தி பல்வேறு வகையான வண்ணங்களை அறிவிக்க, டெவலப்பர்கள் கன்ஸ்ட்ரக்டர்களைப் பயன்படுத்துகின்றனர் - இப்போது அவற்றைப் பார்ப்போம்.

AWT. ஜாவாவில் கலர் கன்ஸ்ட்ரக்டர்கள்

நீங்கள் உருவாக்க விரும்பும் வண்ணத்தின் அளவுருவைப் பொறுத்து, நீங்கள் ஒரு குறிப்பிட்ட வகை வண்ணக் கட்டமைப்பாளரைப் பயன்படுத்த வேண்டும். இவற்றில் ஒரு சில உள்ளன - அவற்றை ஒவ்வொன்றாக ஆராய்வோம்.
  • 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 தீவிர ஒளிபுகாநிலை.

ஜாவா AWT வண்ண வகுப்பில் பயன்படுத்த சிறந்த 15 முறைகள்

ஒரு வண்ணத்தை கையாள, அதன் இருள் அல்லது பிரகாசத்தை சரிசெய்ய, ஜாவா டெவலப்பர்கள் வெவ்வேறு முறைகளை நம்பியுள்ளனர். அவற்றில் டஜன் கணக்கானவை உள்ளன, எனவே அவை அனைத்தையும் நீங்கள் இதயத்தால் கற்றுக்கொள்ள வேண்டியதில்லை. இருப்பினும், மிகவும் பரவலாகப் பயன்படுத்தப்படும் ஜாவா 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());

int getAlpha()

உங்கள் நிறத்தின் ஆல்பா கூறுகளைத் திரும்பப் பெற விரும்பினால், இந்த முறையைப் பயன்படுத்தவும். ஆல்பா மதிப்புகள் 0-255 வரம்பிற்குள் இருக்கும் என்பதை நினைவில் கொள்ளவும். முறையின் பயன்பாடு மற்றும் திரும்புவதற்கான எடுத்துக்காட்டு இங்கே. உதாரணம் :
alpha = Color.black.getAlpha();
return new Color(components[0], components[1], components[2], alpha);

நிலையான வண்ணம் கெட்கலர் (சரம் என்எம்)

ஜாவா டெவலப்பர்கள் இந்த முறையைப் பயன்படுத்தி கணினி பண்புகளைப் பயன்படுத்தி வண்ணத்தைக் கண்டறியலாம். இதேபோன்ற நோக்கங்களைக் கையாளும் பிற முறைகள் உள்ளன:
  • 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, செவ்வகம் 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);

   }
 }
}

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

இது ஒரு ஜாவா முறையாகும், அதன் ஃப்ளோட் அரே மற்றும் ஆல்பா கூறுகளை திரும்பப் பெற வண்ணத்திற்கு நீங்கள் விண்ணப்பிக்கலாம். cspace ஆல் வரையறுக்கப்பட்ட முறைக்கு இந்த முறை பொருந்தும் ColorSpace. உதாரணம் :
public float[] getComponents(ColorSpace cspace, float[] compArray) {

return myColor.getComponents(cspace, compArray);

}

ColorSpace 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(float h, float s, float b)

ஜாவா டெவலப்பர்கள் 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()

இந்த ஜாவா முறை நீங்கள் உருவாக்கிய வண்ணத்திற்கான பச்சை கூறுகளின் மதிப்பை வழங்குகிறது. அனைத்து மதிப்புகளும் RGB வண்ணத் திட்டத்தில் பச்சை நிறத்துடன் தொடர்புடைய வரம்பிற்குள் பொருந்தும். உதாரணம் :
Color clickBoxColor = new Color(color.getRed(), color.getGreen(), color.getBlue(), 20);

getRed()

இதேபோல் getGreen(), getRedகொடுக்கப்பட்ட நிறத்தின் சிவப்பு கூறுக்கான மதிப்பை வழங்குகிறது. மேலே உள்ள எடுத்துக்காட்டில் இந்த முறை எவ்வாறு பயன்படுத்தப்பட்டது என்பதை நீங்கள் ஏற்கனவே பார்த்திருக்கிறீர்கள்.

getBlue()

இந்த முறை RGB வண்ணத் திட்டத்தின் மதிப்புகளின் வரம்பிற்குள் நீலத்தின் மதிப்பை வழங்குகிறது. அதேபோல், பயன்படுத்துவதற்கான உதாரணத்திற்கு getBlue(), இன் விளக்கத்தைப் பார்க்கவும் getGreen().

getAlpha()

ஒரு டெவலப்பர் கொடுக்கப்பட்ட நிறத்தின் ஆல்பா மதிப்பைக் கண்டறிய விரும்பும் போது, ​​getAlpha() முறை ஜாவாவில் பயன்படுத்தப்படுகிறது. RBG ஐப் போலவே, அனைத்து வண்ணங்களின் ஆல்பாக்களும் 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));

ஜாவாவில் பயன்படுத்தப்படும் முக்கிய வண்ணங்களுக்கான வழிகாட்டி

ஜாவாவில் வண்ணங்களைக் கையாளப் பயன்படுத்தப்படும் முறைகளைப் பற்றி இப்போது நீங்கள் புரிந்துகொண்டுள்ளீர்கள், நீங்கள் பணிபுரியும் புல வகைகளைப் பார்ப்போம். ஜாவா டெவலப்பர்கள் வரையறுக்கக்கூடிய உண்மையான நிலையான வண்ணங்கள் இவை. நீங்கள் அதன் பெயரை உள்ளிடுவதன் மூலம் வண்ணத்தை வரையறுக்கலாம் (அதிகாரப்பூர்வ ஆவணத்தில் எழுதப்பட்டதைப் போலவே அதை உள்ளிடுவதை உறுதிப்படுத்தவும்) அல்லது அதன் RGB மதிப்பைக் குறிப்பிடவும். தட்டு உருவாக்குநர்கள் பயன்படுத்துவதைப் பார்ப்போம்:
புலத்தின் பெயர் விளக்கம்
நிலையான நிறம் கருப்பு (கருப்பு) கருப்பு நிறத்தை வரையறுக்கிறது
நிலையான நிறம் வெள்ளை (வெள்ளை) வெள்ளை நிறத்தை வரையறுக்கிறது
நிலையான நிறம் நீலம் (நீலம்) நீலத்தை வரையறுக்கப் பயன்படுகிறது
நிலையான நிறம் சாம்பல் (சாம்பல்) சாம்பல் நிறத்தை வரையறுக்கிறது
நிலையான நிறம் அடர் சாம்பல் (DARK_GRAY) சாம்பல் நிறத்தின் இருண்ட நிழலை வரையறுக்கிறது
நிலையான வண்ண லைட்கிரே (LIGHT_GRAY) சாம்பல் நிறத்தின் லேசான நிழலை வரையறுக்கிறது
நிலையான நிறம் பச்சை (பச்சை) பச்சை நிறத்தை வரையறுக்கப் பயன்படுகிறது
நிலையான வண்ண மெஜந்தா (மெஜந்தா) மெஜந்தா நிழலை வரையறுக்கிறது
நிலையான நிறம் இளஞ்சிவப்பு (பிங்க்) ஜாவாவில் பிங்க் நிறத்தை வரையறுக்கிறது
நிலையான நிறம் ஆரஞ்சு (ஆரஞ்சு) ஜாவாவில் ஆரஞ்சு நிறத்தை உருவாக்குகிறது
நிலையான நிறம் மஞ்சள் (மஞ்சள்) மஞ்சள் நிறத்தை வரையறுக்கப் பயன்படுகிறது
நிலையான நிறம் சிவப்பு (சிவப்பு) ஜாவாவில் சிவப்பு நிறத்தை வரையறுக்கிறது

ஜாவாவில் AWT.Color ஐப் பயன்படுத்துவதில் சிக்கல்களைப் பயிற்சி செய்யவும்

ஜாவாவில் AWT கலரின் உறுதியான அடித்தளம் உங்களிடம் இருப்பது போல் உணர்கிறீர்களா? சில நடைமுறைச் சிக்கல்களைத் தீர்ப்பதன் மூலம் இந்தத் திறன்களைச் சோதிப்போம் - இங்கே, நீங்கள் கன்ஸ்ட்ரக்டர்கள் மற்றும் பொதுவான முறைகள் மற்றும் பிற அல்லாத வண்ணம் தொடர்பான ஜாவா கருவிகளைப் பயன்படுத்த வேண்டும். பயிற்சி சிக்கல் #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
Java.Awt.வண்ண வகுப்பு - 2

முடிவுரை

வாழ்த்துகள், ஜாவாவில் AWT.Color இல் இந்த விரிவான வழிகாட்டியைப் பெற்றுள்ளீர்கள். இப்போது, ​​இடைமுகங்களைக் கையாள்வது மிகவும் எளிதாக இருக்கும். பயிற்சி சிக்கல்கள் மற்றும் கோட்ஜிம் வினாடி வினாக்களைத் தீர்ப்பதன் மூலம் உங்கள் அறிவைப் பயன்படுத்த மறக்காதீர்கள். பயிற்சி சரியானதாக்குகிறது, எனவே மாதிரி சிக்கல்களை உங்கள் சிறந்த ஷாட் கொடுங்கள்!
கருத்துக்கள்
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION