Skip to Content

What are the colors used in Java?

Java includes several classes and methods for working with color. The main color classes in Java are Color and ColorModel. The Color class represents abstract sRGB color values that can be used to paint graphics or text. The ColorModel class is used to interpret pixel values in images and graphics contexts. There are also methods for converting between different color spaces and models.

Color Representation in Java

At the basic level, Java represents colors using RGB (red, green, blue) values. The Color class allows you to create Color objects using RGB integers from 0 to 255. For example:

Color brightRed = new Color(255, 0, 0); // Red 
Color forestGreen = new Color(0, 155, 0); // Green
Color navyBlue = new Color(0, 0, 128); // Blue

You can also create Color objects using hexadecimal RGB strings:

Color tomato = Color.decode("#FF6347"); 
Color limeGreen = Color.decode("#32CD32");

The alpha (transparency) component can be specified as a separate argument from 0 (transparent) to 255 (opaque).

Color translucentWhite = new Color(255, 255, 255, 127);

Java also supports creating colors using the HSB (hue, saturation, brightness) model:

Color crimson = Color.getHSBColor(348.0f, 0.83f, 0.71f);

The hue value ranges from 0 to 360, saturation from 0 to 1, and brightness from 0 to 1.

Standard Java Colors

Java defines several standard colors as public static final Color objects:

Color RGB Value
Color.BLACK (0, 0, 0)
Color.BLUE (0, 0, 255)
Color.CYAN (0, 255, 255)
Color.DARK_GRAY (64, 64, 64)
Color.GRAY (128, 128, 128)
Color.GREEN (0, 255, 0)
Color.LIGHT_GRAY (192, 192, 192)
Color.MAGENTA (255, 0, 255)
Color.ORANGE (255, 200, 0)
Color.PINK (255, 175, 175)
Color.RED (255, 0, 0)
Color.WHITE (255, 255, 255)
Color.YELLOW (255, 255, 0)

These provide common colors that can be used without needing to specify the RGB values each time.

Transparency and Alpha

The Color class supports alpha transparency from 0 (fully transparent) to 255 (fully opaque). This allows creating translucent color effects.

The getAlpha() and getRGB() methods can be used to retrieve the alpha and RGB components of a Color:

int alpha = color.getAlpha();
int rgb = color.getRGB(); 

The RGB value packs the red, green, blue, and alpha into a single int using bitwise operators. You can extract the component values using these methods:

int red = (rgb >> 16) & 0xFF;
int green = (rgb >> 8) & 0xFF; 
int blue = (rgb) & 0xFF;
int alpha = (rgb >> 24) & 0xFF;

The setRGB() method can be used to create a new color by specifying the combined RGBA value:

int rgba = ((alpha & 0xFF) 

Common Color Methods

The Color class provides several useful methods for working with colors:

  • brighter() - Returns a brighter version of this color.
  • darker() - Returns a darker version of this color.
  • getRed(), getGreen(), getBlue() - Get the RGB components.
  • getRGBComponent(int comp) - Get a specific RGB component by index.
  • getHue(), getSaturation(), getBrightness() - Get HSB components.
  • toString() - Convert to a string hex representation like "#FF0000".
  • getColorSpace() - Gets the ColorSpace of the color, usually sRGB.

There are also methods for blending colors:

  • blend() - Blends this color with another color using a blending mode.
  • colorBlend() - Blends two colors together using an extra alpha value.

The Java 2D graphics classes use Color extensively for filling shapes, setting pen colors, etc. The ColorChooser and JColorChooser classes also allow selecting colors interactively.

Color Models

The ColorModel class encapsulates the methods for translating between pixel values and alpha-red-green-blue (ARGB) colors. Different ColorModel implementations handle different color representations like sRGB and CMYK. The main color models used in Java include:

  • DirectColorModel - Direct RGB color model
  • IndexColorModel - Indexed color model with a color lookup table
  • ComponentColorModel - ARGB components color model

The DirectColorModel is used most commonly. The ComponentColorModel uses separate R, G, B (and optionally alpha) samples in an image. IndexColorModel uses a single sample value that is an index into a color lookup table for the final color.

The ColorModel class provides methods to convert between pixel sample values and Color objects. For example:

DirectColorModel model = new DirectColorModel(32, 0xFF0000, 0xFF00, 0xFF);

int rgb = 0xFF000000; // Black with full alpha

Color color = model.getColor(rgb); // Returns Color.BLACK 

The ColorModel represents the way pixel values are interpreted as colors in a particular image format or graphics context.

Color Conversion

Java also provides methods for color space conversion between different models. The main color conversion methods are:

  • Color.RGBtoHSB() - Convert RGB to HSB
  • Color.HSBtoRGB() - Convert HSB to RGB
  • ColorSpace.getInstance() - Gets a ColorSpace like sRGB or CMYK
  • ColorConvertOp - Color conversion operation for images

For example, to convert an sRGB color to CMYK:

ColorSpace sRGB = ColorSpace.getInstance(ColorSpace.CS_sRGB);
ColorSpace CMYK = ColorSpace.getInstance(ColorSpace.CS_CMYK);

ColorConvertOp op = new ColorConvertOp(sRGB, CMYK);

Color sRGBColor = new Color(255, 0, 0); // Red 

Color CMYKColor = op.filter(sRGBColor, null);

This allows converting images between different color models like sRGB and CMYK for printing.


Java provides extensive support for color through the Color, ColorModel, and ColorSpace classes. The Color class represents sRGB color values that can be used for drawing operations. ColorModel encapsulates converting between pixel values and Color objects. Methods like ColorConvertOp allow converting between color spaces like RGB, CMYK, and HSB. Overall, Java's color classes enable full-featured color representation and manipulation.