How would you use S and P flags?
These two flags can only be checked using the CALL or the JP instruction. The Sign flag is used to indicate whether the result of the last operation has a positive or negative result (that is, depending on the operation, the 7th bit or the 15th bit set to 1).
The partiy/overflow flag performs two different functions. Specific instructions will set or reset this flag depening on the parity of the result, which is determined by counting the total number of ones in the result. If this number is odd, partiby bit will be set to 0, otherwise to 1. Parity is most frequently used on blocks of characters. The parity bit is an additional bit which is added to the seven-bit code representing the character, in order to verify the integrity of data which has been stored in a memory device. FOr example, if one bit in the code representing the character has been changed by accident, due to a malfunction in the memory device, then the total number of ones in the seven-bit code will have changed. This error can be detected using the parity flag.
Furthermore, the parity flag is also used as an overflow flag. It detects the fact that, during an addition or subtraction, the sign of the result is "accidentally" changed due to the overflow of the result into the sign bit.
Finally, this bit is also used for two unrelated functions: during the block transfer and search instructions, this flag is used to detect whether the counter register BC has attained the value 0.

How can you represent negative numbers?
Basically, the Z80 doesn't know real negative numbers. However, you can regard the numbers from 0-255 also as numbers from -128 to 127. Take a look at the following example: We want to add a number to A, which will result in an overflow. We'll see what happens.

ld      A, 10
add     A, 254		;overflow: carry set, A = 8

As you see, the result is 8, which would be practically the same as if we would do a SUB 2. Generally speaking, this means that X+(256+Y) = X-Y. Example: 14+(256+(-1)) = 14+255 = 13, which is the same as 14-1. Of course, the compiler will accept code like this:

ld      A, 14
add     A, -1

This is of course more comfortable. As you can see above, negative 8 bit numbers reach from -128 to -1 to 127. This would be, converted with the formula above, 128 (10000000b) to 255 (11111111b) to 127 (01111111b). If you read this carefully, you should have noticed that negative numbers have bit 7 set. So bit 7 can also be referred to as "sign" bit.
The same is true for 16 bit numbers, where the 15th bit can be treated as sign bit.

And what about decimal numbers?
You can handle decimal numbers on the Z80 in two ways:

• Fixed-point decimal numbers: divide a 16 bit (or more bits) number into two sections: integer and fractional part. Typically, you use the upper 8 bits as integer part and the lower 8 bits as fractional part, resulting in an accuracy of 1/256 = 0.0039. Addition and subtraction can be performed just as normal, but after multiplication and division, you have to correct the values again. (example: 8*8 would be $0800 * $0800 = $400000, you have to perform a shift right by 8 bits to get the correct number $4000).
  Fixed point numbers are typically faster, use them in critical passages where you don't need very accurate numbers.
• BCD numbers: this is an approach which can serve you with as accurate numbers as you want, however, processing time is slower and you need special routines. A BCD byte is parted in two 4 bit parts, each representing a number from 0-9. A BCD number can consist of as many BCD bytes as you want. Therefore, if you want to have a 20 digit number, you need 10 BCD bytes and an additional byte specifying the location of the decimal point. Mathematical operations are more difficult to perform, however, the Z80 serves with the DAA instructions, which will correct BCD numbers after addition, subtraction, etc.
  Use BCD if you need very huge or accurate numbers, but not in time-consuming passages.

ld      A, B
or      A
ret     z	;test whether length = 0
Loop:
ld      A, (DE)	;get byte of adder
adc     A, (HL)	;add it to addend, care for carry
daa		;convert to BCD-decimal
ld      (HL), A	;save number back in addend
inc     HL	;next number
inc     DE
djnz    Loop   	;continue until all bytes summed
ret

ld      A, B
or      A
ret     z	;test whether length = 0
ex      DE, HL	;exchange subtrahend and minuend
Loop:
ld      A, (DE)	;get byte of minuend
sbc     A, (HL)	;subtract byte of subtrahend
daa		;convert to BCD-decimal
ld      (DE), A	;save number back in minuend
inc     HL	;next number
inc     DE
djnz    Loop	;continue until all bytes summed
ret

...			;DE contains some important number
push    DE		;save DE onto the stack, as we'll
...			;need it later on
...			;use DE for other stuff meanwhile
pop     DE		;now we need it, load it from stack.
...

...
push    DE		;write DE to memory pointed to by SP-2,
...			;decrement stack pointer by 2 bytes
...
push    HL		;write HL to memory pointed to by SP-2,
...			;decrement SP by 2
;NOTE: if you would now do a pop DE, DE would actually contain
;the value of HL!
pop     BC		;load BC with memory pointed to by SP,
...			;this is, in fact, the previous HL.
...			;After that, increment BC by 2
...
pop     DE		;load DE with memory pointed to by SP,
...			;which is the same as the DE above.
...			;Increment SP by 2 after that.

DE	->	(SP-2), SP = SP-2
  HL	->	(SP-2), SP = SP-2
  BC	<-	(SP), SP = SP+2
DE	<-	(SP), SP = SP+2

;Examples for AND, OR, XOR.
;Using binary numbers to demonstrate effect.
ld      A, 10010101b
and     00001111b	;after that, A = 00000101b
ld      B, 11000000b
or      B		;A = A or B = 11000101b
xor     11111111b	;A = A xor 11111111b = 00111010b

;Examples for shift instructions
ld      A, 00001000b
sla     A		;now, A = 000100000b, Carry = 0
ld      B, 10000000b
sla     B		;B = 00000000b, Carry = 1
ld      C, 00110010b
srl     C		;C = 00011001b, Carry = 0
rrc     C		;C = 10001100b, Carry = 1

LIST:
 .db 10,9,8,7,6,5,4,3,2,1

GetElement:
ld      E, A	;load DE with the index
ld      D, 0
add     HL, DE	;add index to list pointer
ld      A, (HL)	;get number out of list into A
ret

GetElement:
ld      L, C	;get row
ld      H, 0
add     HL, HL	;*2
add     HL, HL	;*4
add     HL, HL	;*8
add     HL, HL	;*16 -> HL = C * 16
add     HL, DE	;add to matrix pointer
ld      E, B	;get column
ld      D, 0
add     HL, DE
ld      A, (HL)	;get element
ret
;Matrix stored like this:
.db 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1	;row 1
.db 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1	;row 2
.db ...