Seems like it's giving the cartesian coordinates of the ends of the three hands of a clock centered at the origin, with up being negative y, and right being positive x. I can say this just by trying some values.

I wrapped your basic code like this:

static class ClockCoords {
    int xs, ys;
    int xm, ym;
    int xh, yh;

    public String toString() {
        return String.format("h: %3d,%3d m: %3d,%3d s: %3d,%3d", xh, yh, xm, ym, xs, ys);
    }
}

public static ClockCoords coords(int h, int m, int s) {
    ClockCoords r = new ClockCoords();
    int xcentre = 0;
    int ycentre = 0;
    r.xs = (int) (Math.cos(s * 3.14f / 30 - 3.14f / 2) * 45 + xcentre);
    r.ys = (int) (Math.sin(s * 3.14f / 30 - 3.14f / 2) * 45 + ycentre);
    r.xm = (int) (Math.cos(m * 3.14f / 30 - 3.14f / 2) * 40 + xcentre);
    r.ym = (int) (Math.sin(m * 3.14f / 30 - 3.14f / 2) * 40 + ycentre);
    r.xh = (int) (Math.cos((h * 30 + m / 2) * 3.14f / 180 - 3.14f / 2) * 30 + xcentre);
    r.yh = (int) (Math.sin((h * 30 + m / 2) * 3.14f / 180 - 3.14f / 2) * 30 + ycentre);
    return r;
}


public static void main(String[] args) throws IOException {
    System.out.println(coords(0, 0, 0));
    System.out.println(coords(0, 0, 45));
    System.out.println(coords(6, 0, 0));
    System.out.println(coords(6, 30, 0));
}

which gives me this:

h:   0,-29 m:   0,-39 s:   0,-44
h:   0,-29 m:   0,-39 s: -44,  0
h:   0, 29 m:   0,-39 s:   0,-44
h:  -7, 28 m:   0, 39 s:   0,-44

So, if I haven't messed this up, the hour hand is 29 units long, the minute hand is 39 units long, and the second hand is 44 units long. At the start of the day, the first entry, they're all pointing straight up. 45 seconds into the day, the second entry, sees the second hand pointing off to the left, but the other two hands are still point straight up given integer granularity and hands that aren't too long. The third entry, 6:00, just flips the hour hand to point down. The fourth entry is interesting, 6:30, in that it points the minute hand down, but also moves the hour hand a little to the left and up...our first hand in a position not at a 90 degree angle to center. Interesting stuff. As to the WHY of all of this...I assume it's all basic trig and cartesian math.

Wait a sec...there one thing strange I don't get...I see in the formulas where each hand is given a different length. Why are the hand lengths I see off by 1 from what's in the formulas? My guess is that it has to do with the very rough approximation of PI that's used. I think those hands aren't pointing quite straight up. That's all I can think of. Maybe tomorrow I'll try plugging in a better value for PI.

Let me provide you some background information as well.

Trigonometry

is all about a circle, having a radius of 1 unit, centered in the origo, that is, point (0, 0). The coordinates of a point on the circle can be calculated as x = cos(alpha), y = sin(alpha), where alpha is the angle. Since all the points of the circle are of equal distance from the center, you only need to know the angle to compute the coordinates, which are (cos(alpha), sin(alpha)).

Reason: Look at Pythagoras's theorem, which is, by the way, a consequence of the law of cosines, where the largest angle of the triangle is of 90 degree.

Pythagoras's theorem states that

where a, b and c are lengths of sides of the triangle, the triangle being perpendicular and a < c > b is true. So, the cos and sin is due to trigonometrical coordinates.

Radians, PI/2

Units of angle can be measured in degrees (360 degrees being the full circle) or radians (2 PI being the full circle). Let's talk in radians. In math, 0 radians is the angle of the upmost point of the circle. pi/2 is the left-most. pi is the downmost. 3pi/2 is the rightmost. Notice, that as the angle increases your point moves counter-clockwise.

Since this is periodic, it is true that

2 * k * pi + alpha = alpha

On screens, y points downwards, by contrast to the standard in math, where y vertex points upwards. So, if you start from 0 radians, that will be the downmost point when shown on the screen and due to the invert y, as you increase the angle, you move to the clockwise direction. Removing pi / 2 from 0 points you to the rightmost point.

Variables

• (xh, yh) are the hour coordinates
• (xm, ym) are the minute coordinates
• (xs, ys) are the second coordinates

They are the hands of a traditional clock.

• h is the hour angle
• m is the minute angle
• s is the second angle

(xcentre, ycentre) are the coordinates of the center. They might be different from (0, 0), so coordinate moving, the so-called translation is supported.

Step sizes

There are 60 seconds in a minute and there are 60 minutes in an hour, so the angle step needs to be the same for them, even though, the frequency of steps is different, while there are 24 hours in a day, so the angle step of hour needs to be both less frequent and larger (12 positions on a traditional clock).

Length of hands

Hour, minute and second hands (no pun intended) differ in their length, this is why the unit of the trigonometric circle is multiplied by 45, 40 and 30, respectively.

As time passes, presumably the angles are changed and subsequently their coordinates change.

A less-exhaustive explanation, looking only at seconds:

xs = (int)(Math.cos(s*3.14f/30-3.14f/2)*45+xcentre);
ys = (int)(Math.sin(s*3.14f/30-3.14f/2)*45+ycentre);

As Steve's answer notes, drawing a line from (xcentre, ycentre) to (xs, ys) would display a seconds-hand, with "up" being "y = 0" -- so that axis is reversed compare to traditional plots. This actually works in our favor: normally, as angles grow, they are displayed as going anti-clockwise. Since the y axis is reversed in screen coordinates, this is fine for us: our hands will advance clockwise, as expected.

Let us look at the maths, using xs:

xs = Math.cos(s*3.14f/30-3.14f/2)*45;          // removed rounding & using xcentre=0
xs = Math.cos((s/30)*PI - PI/2) * sHandLength; // use PI=3.14..., sHandLength=45 

Now, at time 0, we want the seconds-hand to look straight up. But normally cos(0) = 1. If we substract 90º (PI/2), it will be looking straight up:

xs = Math.cos((s/30)*PI - zeroIsUp) * sHandLength;

We can undo this to keep on reasoning about the remaining expression:

xs = Math.cos((s/30)*PI);                      // sHandlength of 1, time 0 is left

All that is missing is that mysterious s/30*PI. Let's make a small table:

seconds(s)        radians(argument to Math.cos())
0                 0
15                PI/2       -- a quarter-turn of the hand
30                PI         -- a half-turn
45                3*PI/2     -- a three-quarters turn
60                2*PI, or 0 -- a full turn

So it seems that it is simply that (s/30) * PI is short for (s/60) * (2*PI).

For a book on Java, I would have expected a much clearer way of writing this. My personal preference would have been:

xs = (int)(Math.cos(base60toRadians(s) - zeroIsUp) * secondHandLength + xCentre);
ys = (int)(Math.sin(base60toRadians(s) - zeroIsUp) * secondHandLength + yCentre);

// ... somewhere else
private float base60toRadians(int b60) { return (b60 / 60) * (2 * Math.PI); } 

The coordinates of the clock's centre are (xcentre, ycentre). With a geometric affine translation to the centre you can calculate like from (0, 0).

The hands are rotating clock wise, in the negative direction.

Now the hands of a clock start at the top, and (0, 1), which has an angle π/2 (90°). (1, 0) being where the angle starts, (-1, 0) halfways having angle π (180°). The full 360° angle being 2π, 1/60^th thereof becomes:

Seconds: 60 seconds = 2π; angle 2π / 60 = π / 30

double startAngle = Math.PI / 2; // Value 0 has angle π/2
double rs = 45;
xs = (int)(Math.cos(-s * Math.PI / 30 - startAngle) * rs + xcentre);
ys = ...        sin ...

Hours: 24 hours = 2π; angle 2π / 24 = π / 12