title: Boxing (informatica)
text: In de informatica is boxing een mechanisme om primitieve types te verpakken in objecten. Deze techniek kan alleen aanwezig zijn in programmeertalen waar er onderscheid is tussen primitieve types en objecten.
  
  Overzicht
  
  De verschillende datastructuren en taalelementen, zoals lijsten en arrays, bieden verschillende functionaliteit: een lijst kan bijvoorbeeld van grootte veranderen terwijl een array een vaste grootte heeft. Een array kan doorgaans gebruikt worden om primitieve types en objecten in op te slaan terwijl een lijst alleen objecten toestaat, zoals een LinkedList in Java.
  
  Soms is het wenselijk om primitieve types, zoals int, ook op te slaan in een LinkedList; dit is normaal gesproken niet mogelijk aangezien men alleen objecten in een de lijst kan stoppen. Met behulp van boxing kunnen de primitieve types in een object gestopt worden om dit mogelijk te maken: de ints kunnen geboxt worden naar Integer-objecten om ze vervolgens in een LinkedList te stoppen (met behulp van genericiteit kan dit type sinds Java 5.0 als LinkedList<Integer> genoteerd worden).
  
  Autoboxing
  
  De term autoboxing wordt gebruikt voor boxing dat automatisch plaatsvindt zonder extra broncode. De compiler genereert automatisch de extra code die nodig is om de typeconversie mogelijk te maken.
  
  Het is bijvoorbeeld sinds Java 5.0 mogelijk om een LinkedList van ints te maken. Dit is niet in tegenspraak met het bovenstaande: een LinkedList kan nog steeds alleen objecten bevatten en niet primitieve types. Maar als Java nu een primitief type aangeleverd krijgt wanneer het een object verwacht dan converteert de compiler automatisch het primitieve type naar een object.
  
  Dit wordt autoboxing genoemd aangezien de conversie automatisch en impliciet gebeurt zonder werk van de programmeur.
  
  Unboxing
  
  Unboxing is het omgekeerde van boxing: het primitieve type uit een object halen.
  
  In Java voor versie 5.0 compileerde het volgende stuk code niet:
  
   Integer i = new Integer(9);
   Integer j = new Integer(13);
   Integer k = i + j; // error!
  
  Sinds Java 5.0 worden i en j unboxt naar int, bij elkaar opgeteld en de som wordt teruggeboxt naar een nieuwe Integer. Oorspronkelijk accepteerde de compiler de laatste regel niet: Integer-objecten zijn op het eerste gezicht niet anders dan andere objecten zoals LinkedList en Object en wiskundige operaties, zoals +, zijn daarvoor niet gedefinieerd. Het volgende stuk code zou wel geaccepteerd worden:
  
   int i = 9;
   int j = 13;
   int k = i + j;
  
  Een ander voorbeeld:
   int x = 4;
   int y = 5;
   // Integer qBox = new Integer(x + y);
   Integer qBox = x + y; // zou fout zijn maar nu wel toegestaan - equivalent met vorige regel
  
  Objectgeoriënteerd programmeren