Como fazer a forma de estrela em Java?

Também pode usar classes existentes, por exemplo http://java-sl.com/shapes.html para polígonos e estrelas regulares.

A classe Polygon pode ser considerada como uma classe legada que está lá desde Java 1.0, mas não deve ser usada mais em novo código. A maneira estranha de especificar as coordenadas x / y em arrays separados, e, mais importante, o fato de que ele só suporta int[] arrays limita suas Áreas de Aplicação. Embora implemente o Shape interface, existem implementações mais modernas desta interface que podem ser usadas para representar polígonos. Na maioria dos casos, descrever o polígono como um Path2D é mais fácil e mais flexível. Pode-se criar um Path2D p = new Path2D.Double(); e então fazer uma sequência de moveTo e lineTo chamadas para genear a forma desejada.

O seguinte programa mostra como a classe Path2D pode ser usada para gerar formas estelares. O método mais importante é o método createStar. É muito genérico. Recebe

As coordenadas centrais da estrela
• o raio interior e exterior da estrela
• O número de raios que a estrela deve ter
• O ângulo onde o primeiro raio deve estar (isto é, o ângulo de rotação da estrela)

Se desejado, um método mais simples pode ser enrolado em torno deste-como com o exemplo createDefaultStar no código abaixo.

O programa mostra Estrelas diferentes, pintadas como linhas e cheias com cores diferentes e tintas radiais em gradiente, como exemplos:

O programa completo como um MCVE :

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.RadialGradientPaint;
import java.awt.RenderingHints;
import java.awt.Shape;
import java.awt.geom.Path2D;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;

public class DrawStarShape
{
    public static void main(String[] args)
    {
        SwingUtilities.invokeLater(new Runnable()
        {
            @Override
            public void run()
            {
                createAndShowGUI();
            }
        });
    }

    private static void createAndShowGUI()
    {
        JFrame f = new JFrame();
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.getContentPane().add(new DrawStarShapePanel());
        f.setSize(600, 600);
        f.setLocationRelativeTo(null);
        f.setVisible(true);
    }

}

class DrawStarShapePanel extends JPanel
{
    @Override
    protected void paintComponent(Graphics gr)
    {
        super.paintComponent(gr);
        Graphics2D g = (Graphics2D) gr;
        g.setColor(Color.WHITE);
        g.fillRect(0, 0, getWidth(), getHeight());
        g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
            RenderingHints.VALUE_ANTIALIAS_ON);

        g.setColor(Color.BLACK);
        g.draw(createDefaultStar(50, 200, 200));

        g.setPaint(Color.RED);
        g.fill(createStar(400, 400, 40, 60, 10, 0));

        g.setPaint(new RadialGradientPaint(
            new Point(400, 200), 60, new float[] { 0, 1 }, 
            new Color[] { Color.RED, Color.YELLOW }));
        g.fill(createStar(400, 200, 20, 60, 8, 0));

        g.setPaint(new RadialGradientPaint(
            new Point(200, 400), 50, new float[] { 0, 0.3f, 1 }, 
            new Color[] { Color.RED, Color.YELLOW, Color.ORANGE }));
        g.fill(createStar(200, 400, 40, 50, 20, 0));

    }

    private static Shape createDefaultStar(double radius, double centerX,
        double centerY)
    {
        return createStar(centerX, centerY, radius, radius * 2.63, 5,
            Math.toRadians(-18));
    }

    private static Shape createStar(double centerX, double centerY,
        double innerRadius, double outerRadius, int numRays,
        double startAngleRad)
    {
        Path2D path = new Path2D.Double();
        double deltaAngleRad = Math.PI / numRays;
        for (int i = 0; i < numRays * 2; i++)
        {
            double angleRad = startAngleRad + i * deltaAngleRad;
            double ca = Math.cos(angleRad);
            double sa = Math.sin(angleRad);
            double relX = ca;
            double relY = sa;
            if ((i & 1) == 0)
            {
                relX *= outerRadius;
                relY *= outerRadius;
            }
            else
            {
                relX *= innerRadius;
                relY *= innerRadius;
            }
            if (i == 0)
            {
                path.moveTo(centerX + relX, centerY + relY);
            }
            else
            {
                path.lineTo(centerX + relX, centerY + relY);
            }
        }
        path.closePath();
        return path;
    }
}

Tenho 2 métodos.

1)

public static Bitmap drawStar(int W, int H, int color, boolean andRing)
{
    Path path = new Path();
    Bitmap output = Bitmap.createBitmap(W, H, Config.ARGB_8888);
    Canvas canvas = new Canvas(output);
    final Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
    paint.setColor(color);

    float midW ,min ,fat ,half ,radius;

    if(andRing)
    {
        midW = W / 2;
        min = Math.min(W, H);
        half = min / 2;
        midW = midW - half;

        fat = min / 17;
        radius = half - fat;

        paint.setStrokeWidth(fat);
        paint.setStyle(Paint.Style.STROKE);
        canvas.drawCircle(midW + half, half, radius, paint);

        path.reset();
        paint.setStyle(Paint.Style.FILL);
        path.moveTo( half * 0.5f, half * 0.84f);
        path.lineTo( half * 1.5f, half * 0.84f);
        path.lineTo( half * 0.68f, half * 1.45f);
        path.lineTo( half * 1.0f, half * 0.5f);
        path.lineTo( half * 1.32f, half * 1.45f);
        path.lineTo( half * 0.5f, half * 0.84f);
    }
    else
    {
        min = Math.min(W, H);
        half = min/2;

        path.reset();
        paint.setStyle(Paint.Style.FILL);

        path.moveTo( half * 0.1f  , half * 0.65f);
        path.lineTo( half * 1.9f  , half * 0.65f);
        path.lineTo( half * 0.40f , half * 1.65f);
        path.lineTo( half       , 0           );
        path.lineTo( half * 1.60f, half * 1.65f);
        path.lineTo( half * 0.1f, half * 0.65f);
    }

    canvas.drawPath(path, paint);

    return output;
}

2)

  public static Bitmap drawStar(int W,int H,int spikes,int innerRadius,int outerRadius, int backColor,boolean border, int borderColor)
{
    if(W < 10)
        W = 10;

    if(H < 10)
        H = 10;

    if(spikes < 5)
        spikes = 5;

    int smallL = W;

    if(H < W)
        smallL = H;

    if(outerRadius > smallL/2)
        outerRadius = smallL/2;

    if(innerRadius < 5)
        innerRadius = 5;

    if(border)
    {
        outerRadius -=2;
        innerRadius -=2;
    }

    Path path = new Path();
    Bitmap output = Bitmap.createBitmap(W, H, Config.ARGB_8888);
    Canvas canvas = new Canvas(output);
    final Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
    paint.setColor(backColor);
    int cx = W/2;
    int cy = H/2;

    double rot = Math.PI / 2 * 3;
    float x,y;
    double step = Math.PI / spikes;

    path.moveTo(cx, cy - outerRadius);

    for (int i = 0; i < spikes; i++)
    {
        x = (float) (cx + Math.cos(rot) * outerRadius);
        y = (float) (cy + Math.sin(rot) * outerRadius);
        path.lineTo(x, y);
        rot += step;

        x = (float) (cx + Math.cos(rot) * innerRadius);
        y = (float) (cy + Math.sin(rot) * innerRadius);
        path.lineTo(x, y);
        rot += step;
    }

    path.lineTo(cx, cy - outerRadius);
    path.close();

    canvas.drawPath(path, paint);

    if(border)
    {
        paint.setStyle(Style.STROKE);
        paint.setStrokeWidth(2);
        paint.setColor(borderColor);
        canvas.drawPath(path, paint);
    }
    return output;
}