మీరు జావా అబ్‌స్ట్రాక్ట్ టూల్‌కిట్‌ను మాస్టరింగ్ చేస్తుంటే, మీరు జావా AWT కలర్ క్లాస్ అప్లికేషన్‌లను నేర్చుకోవాలి. ఇందులో చాలా మంది కన్స్ట్రక్టర్లు మరియు పద్ధతులు ఉన్నందున, ఇది మొదట బెదిరింపుగా అనిపించవచ్చు. కానీ చింతించకండి, మేము మిమ్మల్ని కవర్ చేసాము :) Java AWT కలర్‌పై ఈ పూర్తి తగ్గింపుతో, మీరు కొత్త రంగు రకాన్ని ఎలా సృష్టించాలో మరియు ఏ సమయంలోనైనా ఎలా నిర్వహించాలో నేర్చుకుంటారు. మేము మీ నైపుణ్యాన్ని మెరుగుపరచడంలో మీకు సహాయపడే కొన్ని అభ్యాస పరీక్షలను కూడా అందిస్తాము.
జావాలో AWT కలర్ క్లాస్ అంటే ఏమిటి?
RGB (ఎరుపు, ఆకుపచ్చ, నీలం), RGBA (ఎరుపు, ఆకుపచ్చ, నీలం, ఆల్ఫా) లేదా HSB (రంగు, సంతృప్తత, BRI భాగాలు) ప్యాకేజీలను ఉపయోగించి Java కోడ్‌ని ఉపయోగించి కొత్త రంగులను రూపొందించడానికి డెవలపర్‌లను అనుమతించడం AWT రంగు యొక్క ప్రాథమిక ఉద్దేశ్యం. తరగతి రెండు విలువలను కలిగి ఉంది - నీడ యొక్క కోడ్ మరియు అస్పష్టత/పారదర్శకత విలువ. మీరు Class 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)మీరు ముందుగా పేర్కొన్న కలర్‌స్పేస్‌లో రంగును నిర్వచిస్తుంది. డెవలపర్ నిర్వచించిన ఆల్ఫా యొక్క ఫ్లోట్ శ్రేణిలో రంగు భాగాల పరిధిని నిర్దేశిస్తారు.
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 రంగు పద్ధతుల విషయానికి వస్తే, మేము జాబితాను పదిహేనుకి తగ్గించాము. Java API డాక్యుమెంటేషన్‌ను సూచించాల్సిన అవసరం లేకుండా వీటిని గుర్తుంచుకోవడం డెవలపర్‌లకు సహాయకరంగా ఉంటుంది.
ముదురు ()
మీరు ఇప్పటికే నిర్వచించిన రంగుకు ముదురు రంగులో ఉండే కొత్త రంగును సృష్టించడానికి ఈ పద్ధతి ఉపయోగించబడుతుంది. ఉదాహరణ :
Color.green.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)
స్టాటిక్ కలర్ డీకోడ్ (స్ట్రింగ్ nm)
ఈ పద్ధతి రంగును స్ట్రింగ్‌గా ప్రదర్శించడానికి ఉపయోగించబడుతుంది. మార్పిడి పూర్తయిన తర్వాత, డెవలపర్ నిర్వచించిన అపారదర్శక రంగును పొందుతారు. ఉదాహరణ :
public static Color decodeColor(String hexColor) {
return Color.decode(hexColor);
ఈ పద్ధతి సంక్లిష్టంగా కనిపిస్తుంది, కానీ కనిపించే దానికంటే మార్చడం సులభం. 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);
}
}
}
ఇది జావా పద్ధతి, మీరు దాని ఫ్లోట్ శ్రేణి మరియు ఆల్ఫా భాగాలను తిరిగి ఇవ్వడానికి రంగుకు వర్తించవచ్చు. ఈ పద్ధతి cspace ద్వారా నిర్వచించబడిన వాటికి వర్తిస్తుంది ColorSpace. ఉదాహరణ :
జావా డెవలపర్లు ఎంచుకున్న రంగు కోసం రంగు స్థలాన్ని తిరిగి ఇవ్వడానికి ఈ పద్ధతిని ఉపయోగించవచ్చు. 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(ఫ్లోట్ హెచ్, ఫ్లోట్ ఎస్, ఫ్లోట్ బి)
జావా డెవలపర్లు 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)
లేత బూడిద రంగును నిర్వచిస్తుంది
స్టాటిక్ కలర్ గ్రీన్ (గ్రీన్)
ఆకుపచ్చ రంగును నిర్వచించడానికి ఉపయోగిస్తారు
స్టాటిక్ కలర్ మెజెంటా (మెజెంటా)
మెజెంటా నీడను నిర్వచిస్తుంది
స్టాటిక్ కలర్ పింక్ (పింక్)
జావాలో గులాబీని నిర్వచిస్తుంది
స్టాటిక్ కలర్ ఆరెంజ్ (ఆరెంజ్)
జావాలో నారింజ రంగును సృష్టిస్తుంది
స్థిర రంగు పసుపు (పసుపు)
పసుపును నిర్వచించడానికి ఉపయోగిస్తారు
స్టాటిక్ కలర్ రెడ్ (RED)
జావాలో ఎరుపు రంగును నిర్వచిస్తుంది
జావాలో AWT.Colorని ఉపయోగించడం కోసం ప్రాక్టీస్ ప్రాబ్లమ్స్
మీరు జావాలో AWT కలర్‌కు బలమైన పునాది ఉన్నట్లు భావిస్తున్నారా? కొన్ని ఆచరణాత్మక సమస్యలను పరిష్కరించడం ద్వారా ఈ నైపుణ్యాలను పరీక్షిద్దాం - ఇక్కడ, మీరు కన్స్ట్రక్టర్లు మరియు సాధారణ పద్ధతులను అలాగే ఇతర రంగు-సంబంధిత జావా సాధనాలను వర్తింపజేయాలి. ప్రాక్టీస్ సమస్య #1 . ప్రోగ్రామ్ వినియోగదారుని RGB స్థాయిలను రంగులో సర్దుబాటు చేయడానికి అనుమతించే కస్టమ్ కాంపోనెంట్‌ను సృష్టించండి (ఇలాంటిది 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లో ఈ విస్తృతమైన గైడ్ ద్వారా పొందారు. ఇప్పుడు, ఇంటర్‌ఫేస్‌లను నిర్వహించడం చాలా సులభం అవుతుంది. అభ్యాస సమస్యలు మరియు కోడ్‌జిమ్ క్విజ్‌లను పరిష్కరించడం ద్వారా మీ జ్ఞానాన్ని వర్తింపజేయడం మర్చిపోవద్దు. ప్రాక్టీస్ పరిపూర్ణంగా ఉంటుంది కాబట్టి నమూనా సమస్యలకు మీ ఉత్తమ షాట్ ఇవ్వండి!
మీరు Class java.awt.Colorని ఎలా ప్రకటిస్తారు:
GO TO FULL VERSION