I gradienti sono esteticamente gradevoli le transizioni tra i colori. Java elabora automaticamente diversi tipi di gradienti tra utente specificato colori. È possibile impostare una sfumatura come un colore mentre si disegna in Java per creare forme, testo e altri oggetti con un effetto sfumato. Se classi gradienti di default di Java non sono abbastanza flessibili, è possibile elaborare il tuo sfumature in Java con cicli nidificati.

Classe GradientPaint

La classe GradientPaint fornisce il metodo più semplice di creare una sfumatura semplice. Costruttore di GradientPaint accetta due punti, due colori e un valore booleano opzionale. La pendenza risultante si sposterà dal primo colore nel primo punto al secondo colore corrispondenza del secondo punto. Se si passa il valore booleano true, il gradiente verrà ripetuta la sfumatura in entrambe le direzioni passato i punti iniziale e finale, creando un modello ciclico. Un oggetto GradientPaint che passa in rassegna blu e bianco viene creata un'istanza come tale:

GradientPaint p = GradientPaint nuovo (nuovo Point(0,0), color. Blue, nuovo Point (100,100), Color.WHITE,true);

Classe LinearGradientPaint

LinearGradientPaint è simile a GradientPaint, ma può creare una sfumatura attraverso più di due colori e permette agli utenti di definire la larghezza dovrebbe essere ogni sezione colorata della sfumatura. Costruttore di LinearGradientPaint accetta due punti, una matrice dei carri allegorici, una matrice di colori e un valore opzionale per indicare come il gradiente deve scorrere i colori. Ogni valore float corrisponde a un colore e indica a che punto della sfumatura che colore dovrebbe essere predominante. Ad esempio, se il gradiente deve essere blu un terzo del modo attraverso il suo ciclo 0.3f deve corrispondere con il colore blu. Un oggetto LinearGradientPaint che crea una sfumatura attraverso blu, bianco e nero senza ripetere utilizza il seguente costruttore:

float [] x = {0.3f, 0.0 f, 1.0 f};
Colore c [] = {color. Black, color. Blue, color. White};
LinearGradientPaint lp = LinearGradientPaint nuovo (nuovo Point(0,0), nuovo Point (100,100), x, c);

Classe RadialGradientPaint

RadialGradientPaint crea sfumature circolari che si estende da un unico punto. Il costruttore accetta un singolo punto che rappresenta il centro del cerchio, un valore di float che rappresenta il raggio del cerchio, una matrice di galleggianti per rappresentare il tasso di variazione tra colori e una matrice di colori. Facoltativamente, può accettare un punto di messa a fuoco che sposta il centro della sfumatura per creare sfumature ellittiche e un valore per determinare come il gradiente di cicli attraverso i colori. Un'istanza di un oggetto RadialGradientPaint è simile alla creazione di un LinearPaintObject:

float [] x = {0.3f, 0.0 f, 1.0 f};
Colore c [] = {color. Black, color. Blue, color. White};
LinearGradientPaint lp = LinearGradientPaint nuovo (nuovo Point(50,50), (float) 25, x, c);

Pittura di una sfumatura

È possibile creare sfumature personalizzate più elaborate in Java elaborando la propria sfumatura attraverso cicli nidificati. A ogni passaggio nel ciclo, creare un nuovo colore in base alla posizione nel ciclo. Nel ciclo più interno, disegnare un quadrato in una posizione definita dalla vostra posizione nel ciclo nel colore corrente. Il codice nell'esempio seguente crea un rettangolo sfumato che inizia nel punto (0,0) e 400 pixel di larghezza e 500 pixel di altezza. Il galleggiante valori r1, g1 e b1 definire i valori r, g e b del colore iniziale. I valori r2, g2 e b2 definiscono i valori r, g e b per il secondo colore. Il primo ciclo viene eseguito dalla coordinata x iniziale alla larghezza del rettangolo. Il ciclo interno viene eseguito dalla coordinata y iniziale per l'altezza del rettangolo. Così, nel ciclo interno, il punto (i, j) corrisponde sempre a un punto diverso nel rettangolo sfumato. Ogni volta che il programma cicli attraverso il ciclo nidificato, esso modifica la r e b i valori come frazione della corrente x coordinano; il più vicino il punto è al valore iniziale di x, il più vicino i valori r e b sarà sui valori iniziali. Il programma consente di modificare il valore di b relativo alla coordinata y corrente, creando lo stesso effetto su un asse diverso. Quindi crea un nuovo colore dai valori modificati di r, g e b e disegna un rettangolo di esattamente un pixel in larghezza e altezza presso la coordinata corrente nel nuovo colore.

int x = 0; int y = 0;
int width = 400; altezza int = 500;
galleggiare r1 = 0; galleggiante g1 = 0; galleggiante b1 = 1;
galleggiare r2 = 1; galleggiante g2 = 1; galleggiare b2 = 0;
galleggiante rS = Math.abs(r2-r1);
galleggiare gS = Math.abs(g2-g1);
float b = Math.abs(b2-b1);
per (int i = x; i < larghezza; i + +) {

for(int j = y; j < height;j++){
float r,g,b;
if(r1<r2){ r = (((rS)/width)*i)+r1;}
else{r = (r1-((rS)/width)*i);}
if(g1<g2){g = (((gS)/width)*i)+g1;}
else{g = (g1-((gS)/width)*i);}
if(b1<r2){b = (((bS)/width)*i)+b1;}
else{b = (b1-((bS)/width)*i);}
Color c = new Color(r,g,b,(float)0.5);
g2d.setColor(c);
g2d.fillRect(i, j, 1, 1);
}

}