1. Omslagsklasser
Varje primitiv typ har en motsvarande klass, en så kallad omslagsklass (wrapper klass). Omslagsklasserna har nästan samma namn som respektive primitiv typ, men med stor bokstav. Men omslagsklassen till int kallas Integer och chars kallas Character. Omslagsklassernas värden kan inte förändras, så de används inte till beräkningar. Istället är de bra att ha för att lagra primitiver i behållare som bara kan lagra objekt (som Vector), eller till omvandlingar.
2. Initiering
- Alla omslagsklasser kan initieras med en variabel av den primitiva typ de representerar.
- Alla omslagsklasserna utom Boolean kan initieras med ett litterärt tal. Men omslagsklasserna klarar inte att som de primitiva typerna konvertera till en mindre typ. Ett litterärt heltal tolkas nämligen som en int. Därför måste klasserna Byte, Short och Character göra en explicit typomvandling.
- Alla omslagsklasser utom Character kan även initieras med en litterär sträng. I fallet med Character får man använda enkelfnuttar kring ett tecken.
Nedan följer ett exempel med godkända initieringar:
class TestTypeClass{
public static void main(String[] args){
Boolean b=new Boolean(false);
Byte a=new Byte((byte) 2); // Typecasting needed
Short s=new Short((short) 2); // Typecasting needed
Character c=new Character((char) 2); // Typecasting needed
Integer i=new Integer(2);
Long l=new Long(2);
Float f=new Float(1.2);
Double d=new Double(1.2);
Boolean b2=new Boolean("true");
Byte a2=new Byte("2");
Character c2=new Character('d'); // Single quotes
if(b2.booleanValue())
System.out.println("Allt funkar");
}
}
|
Vi kör programmet:
[olle@dev1]$ java TestTypeClass
Allt funkar
|
3. Allmänna medlemmar
Den numeriska omslagsklasserna delar en mängd metoder. Nedan listar vi de medlemmar som Integer har gemensamt med de övriga omslagsklasserna. Klassen Double har liknande metoder men med int bytt mot double på ett flertal ställen:
| Metod | | Returtyp | | Statisk | | Beskrivning |
|---|
| MAX_VALUE | | int | | Ja | | Returnerar det största talet int kan innehålla |
| MIN_VALUE | | int | | Ja | | Returnerar det största talet int kan innehålla |
| parseInt(str) | | int | | Ja | | Tolkar str som ett heltal |
| parseInt(str,y) | | int | | Ja | | Tolkar str som ett heltal med basen y |
| valueOf(str) | | Integer | | Ja | | Tolkar str som ett heltal |
| valueOf(str,y) | | Integer | | Ja | | Tolkar str som ett heltal med basen y |
| toString(i) | | String | | Ja | | Omvandlar i till en sträng |
| toString() | | String | | Nej | | Omvandlar instansen till en sträng |
| byteValue() | | byte | | Nej | | Omvanldar instansen till en byte |
| shortValue() | | short | | Nej | | Omvanldar instansen till en short |
| intValue() | | int | | Nej | | Omvanldar instansen till en int |
| longValue() | | long | | Nej | | Omvanldar instansen till en long |
| floatValue() | | float | | Nej | | Omvanldar instansen till en float |
| doubleValue() | | double | | Nej | | Omvanldar instansen till en double |
| equals(x) | | boolean | | Nej | | Jämför objektet x (Integer) med instansen. Returnerar true om instansen är lika med x, annars false. |
| compare(x) | | int | | Nej | | Jämför objektet x (Integer) med instansen. Returnerar 1 om instansen är större än x, 0 om lika och -1 om mindre. |
Som synes är vissa metoder statiska och andra instans-metoder. Metoden toString finns i båda formerna. Vi testar några allmänna metoder:
class TestInteger{
public static void main(String[] args){
Integer i=new Integer(8);
System.out.println("string="+i.toString());
System.out.println("byte="+i.byteValue());
System.out.println("short="+i.shortValue());
System.out.println("int="+i.intValue());
System.out.println("long="+i.longValue());
System.out.println("float="+i.floatValue());
System.out.println("double="+i.doubleValue());
}
}
|
Vi får utskriften:
[olle@dev1]$ java TestInteger
string=8
byte=8
short=8
int=8
long=8
float=8.0
double=8.0
|
Här ser vi att vi kan konvertera till vilken primitiv typ som helst utom till char och boolean. Alla numeriska omslagsklasser har dessa metoder. Vanligast är kanske att man använder omslagsklasser för att omvandla strängar till tal, det finns två sätt:
class TestWrapper2{
public static void main(String[] args){
String s="11.22";
Double dClass= Double.valueOf(s);
double dPrim= Double.parseDouble(s);
}
}
|
Programmet ovan kompilerar utan problem.
4. Jämföra omslagsobjekt
Om man försöker jämföra två omslagsobjekt med == jämför man bara om referenserna pekar på samma objekt. Istället ska man jämföra omslagsobjekt med equals() och compareTo().Märk att dessa funktioner bara kan jämföra två objekt, inte ett objekt med en primitiv typ:
class TestCompare{
public static void main(String[] args){
Integer iObj=new Integer(5);
Integer jObj=new Integer(-1);
System.out.println("compatareTo="+iObj.compareTo(jObj));
System.out.println("equals="+iObj.equals(jObj));
}
}
|
Vi kör programmet:
[olle@dev1]$ java TestCompare
compareTo=1
equals=false
|
5. Integer och Long
Nedan listas några metoder som bara Integer och Long har:
| Metod | | Returtyp | | Statisk | | Beskrivning |
|---|
| toBinaryString(i) | | String | | Ja | | Omvandlar i till en binärsträng |
| toOctalString(i) | | String | | Ja | | Omvandlar i till en oktal sträng |
| toHexString(i) | | String | | Ja | | Omvandlar i till en hexadecimal sträng |
I detta exempel använder vi dessa:
class TestInteger2{
public static void main(String[] args){
int i=8;
System.out.println("binary str="+Integer.toBinaryString(i));
System.out.println("octal str="+Integer.toOctalString(i));
System.out.println("hex str="+Integer.toHexString(i));
}
}
|
Vid en körning får vi följande utskrift:
[olle@dev1]$ java TestInteger2
binary str=1000
octal str=10
hex str=8
|
Dessa metoder kan vara trevliga att använda för felsökning då man gör
binära beräkningar . Man kan även tolka en sträng som tal i en annan bas:
class TestWrapper3{
public static void main(String[] args){
String s=="1E";
int i=Integer.parseInt(s,16);
System.out.println("Base 10="+i);
}
}
|
När 1E tolkas med basen 16 blir det 16+14=30:
[olle@dev1]$ java TestWrapper3
Base 10=30
|
6. Float och Double
Omslagsklasserna för flyttal innehåller några speciella konstanter:
| Konstanter | | Beskrivning |
|---|
| NEGATIVE_INFINITY | | Representerar ett negativt oändligt tal. |
| POSITIVE_INFINITY | | Representerar ett positivt oändligt tal. |
| NaN | | Representerar ett tal som inte är ett tal(!) |
Negativ och positiv oändlighet uppkommer oftast då man dividerar med 0. En sådan division kastar INTE undantag eftersom vi rör oss med flyttal:
class TestDivZero{
public static void main(String[] args){
double d=1.2;
d=d/0;
System.out.println("Division ok! d="+d);
if(d==Double.POSITIVE_INFINITY)
System.out.println("d is infinity");
}
}
|
Programmet genererar utskriften:
[olle@dev1]$ java TestDivZero
Division ok! d=Infinity
d is infinity
|
NaN kan bara testas med funktionen isNaN(), det kan tyckas ologiskt:
class TestNaN{
public static void main(String[] args){
double d=-1.2;
d=Math.sqrt(d);
if(d==Double.NaN)
System.out.println("Equals NaN");
if(Double.isNaN(d))
System.out.println("Function said NaN");
}
}
|
Utskriften blir:
[olle@dev1]$ java TestNaN
Function said NaN
|
7. Omslagsklasser Character
Med omslagsklassen Chararacter kan man kontrollera teckentyp hos en char:
| Metod | | Returtyp | | Statisk | | Beskrivning |
|---|
| isLetter() | | boolean | | Ja | | Kollar om Character är en bokstav |
| isDigit() | | boolean | | Ja | | Kollar om Character är en siffra |
| isJavaIdentifierStart() | | boolean | | Ja | | Kollar om Character kan användas som första tecken i en identifierare |
Följande exempel testar metoderna:
class TestWrapperChar{
public static void main(String[] args){
char c='p';
if(Character.isLetter(c))
System.out.println(c+" is a letter");
if(Character.isJavaIdentifierStart(c))
System.out.println(c+" is identifier!");
char d='1';
if(Character.isDigit(d))
System.out.println(d+" is a digit");
if(Character.isJavaIdentifierStart(d))
System.out.println(d+" is identifier!");
}
}
|
Programmet får följande utskrift:
[olle@dev1]$ java TestWrapperChar
p is a letter
p is identifier!
1 is a digit
|
