programmera.net -> java -> normal     för utskrift      info@programmera.net

Omslagsklasser

1. Omslagsklasser
2. Initiering
3. Allmänna medlemmar
4. Jämföra omslagsobjekt
5. Integer och Long
6. Float och Double
7. Omslagsklasser Character

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