1. Math
Om du vill göra lite mer avancerade numeriska beräkningar använder du Math. På denna sida listas några metoder och konstanter som klassen har. Några fakta man bör känna till om Math är:
- Denna klass är helt statisk (har bara statiska medlemmar), alltså behöver kan man inte skapa ett objekt av klassen innan man använder den.
- Eftersom klassen ligger i paketet lang behöver du heller inte importera den.
- Klassen är final, så ingen klass kan ärva av Math.
Nedan ges en överblick av några intressanta metoder och konstanter:
| Medlem | | Returtyp | | Beskrivning |
|---|
| PI | | double | | Konstanten Pi (ca: 3.14) |
| E | | double | | Konstanten E (ca: 2.71) |
| abs(x) | | olika | | Returnerar x eller -x om x är negativt |
| max(x,y) | | olika | | Returnerar det högsta värdet av x och y |
| min(x,y) | | olika | | Returnerar det minsta värdet av x och y |
| round(x) | | olika | | Avrundar x till närmaste heltal |
| ciel(x) | | double | | Avrundar x upp till närmaste heltal (men returtypen är double) |
| floor(x) | | double | | Avrundar x ner till närmaste heltal (men returnerar double) |
| sqrt(x) | | double | | Returnerar roten ur x |
| pow(x,y) | | double | | Returnerar x upphöjt till y |
| cos(x) | | double | | Returnerar Tangens av x, där x är radianer |
| sin(x) | | double | | Returnerar Sinus av x, där x är radianer |
| tan(x) | | double | | Returnerar Cosinus av x, där x är radianer |
| random() | | double | | Returnerar ett slumpvärde mellan 0 och 1 |
Vi ser att den vanligaste returtypen är double, men ibland kan andra typer också returneras. Hur detta går till förklaras i avsnitten nedan.
2. Konstanter
De konstanter du vanligtvis behöver i en beräkning är pi och talet e. Båda dessa är av typen double:
class TestPi{
public static void main(String[] args){
System.out.println("pi="+Math.PI);
System.out.println("e="+Math.E);
}
}
|
Utskriften blir:
[olle@dev1]$ java TestPi
pi=3.141592653589793
e=2.718281828459045
|
3. abs, max, och min
Dessa metoder är överlagrade och har alltså olika returtyp beroende på argumentens typ. De kan returnera int, long, float, double. Kom ihåg att mindre typer automatiskt konverteras till int:
class TestMin{
public static void main(String[] args){
byte a=-2;
byte b=1;
int i;
i=Math.min(a,b);
System.out.println("min="+i);
}
}
|
Vi får utskriften:
[olle@dev1]$ java TestMin
-2
|
4. round, ciel och floor
Metoden round är överlagrad. Om argumentets typ är float returneras en int. Om argumentets typ är double returneras long. Nedan ges ett exempel:
class TestRound{
public static void main(String[] args){
float f=2.3f;
int i;
i=Math.round(f);
System.out.println("round="+i);
}
}
|
Vid kompilering får vi följande:
[olle@dev1]$ java TestRound
round=2
|
Av någon märklig anledning returnerar metoderna ciel och floor alltid double, trots att de avrundar till heltal:
class TestFloor{
public static void main(String[] args){
double ret,d=2.3;
ret=Math.floor(d);
System.out.println("floor="+ret);
}
}
|
Föjlande program ger utskriften:
[olle@dev1]$ java TestFloor
ret=2.0
|
5. pow och sqrt
Här är ett exempel på hur du använder pow:
class TestMath{
public static void main(String[] args){
int i=3;
System.out.println("square="+Math.pow(i,2));
}
}
|
Programmet skriver:
[olle@dev1]$ java TestMath
square=9.0
|
Metoden sqrt beräknar roten ur ett tal (square root). Ett vanligt misstag är att man glömmer att kontrollera att argumentet är större än noll. JVM reagerar inte på detta utan returnerar fridfullt Math.NaN (Not a Number).
class TestSqrt{
public static void main(String[] args){
int i=-2;
double ret;
ret=Math.sqrt(i);
System.out.println("root="+ret);
}
}
|
Vi kör programmet:
[olle@dev1]$ java TestSqrt
root=NaN
|
Vill man kontrollera om man har NaN i en variabel, måste man använda funktionen isNaN:
class TestNN{
public static void main(String[] args){
if(Double.isNaN(Math.sqrt(-2))){
System.out.println("Not A Number");
}
}
}
|
Programmet ger:
[olle@dev1]$ java TestNN
Not A Number
|