Le champ magic permet d'identifier un fichier comme étant un fichier .class. Il a toujours pour valeur 0xCAFEBABE. Nous pouvons donc écrire :

final int magic = 0xCAFEBABE;

Les champs minorVersion et majorVersion indiquent le numéro de version du fichier .class. La JDK 1.0.2 supporte les versions comprises dans l'intervalle [45.0; 45.3], la JDK 1.1.* dans l'intervalle [45.0; 45.65536] et les JDK 1.k supportent les versions dans l'intervalle [45.0; 44+k.0] où k >= 2.

Par exemple, la JDK7 supporte les versions de fichiers .class comprises dans l'intervalle [45.0; 51.0].

Or comme mentionné dans la partie 3 (Part 3 - Bytecode - Constantes), nous allons nous concentrer sur Java 1.4 (version 48.0), nous pouvons rassembler les deux champs par un seul (version) :

// 48 = 0x00 (version mineure) | 0x30 (version majeure)
final private short version = 0x30;

0x30 étant une valeur littérale inférieure à 32 767 nous n'avons pas besoin de la caster pour l'assigner à un short. Néanmoins, comme nous l'avons déjà vu, la JVM préfère manipuler des int. Par conséquent, rien ne nous empêche d'écrire :

final private int version = 0x30;

Il suffira de ne pas oublier, lors de la génération du fichier classe, d'appeler la méthode writeShort() de la classe DataOutputStream, et non writeInt().

La partie suivante est assez particulière. Elle représente un pool de constantes et n'a aucun équivalent en Java. Elle a pour but de rassembler toutes les constantes présentes dans le code, comme le nom d'une classe ou d'une méthode, des littérales et des valeurs de constantes définies dans le code.

Le tableau constantPool est indexé de 1 à constantPoolCount - 1. L'index 0 est réservé pour l'utilisation de la JVM.

Chaque classe peut avoir jusqu'à 65 535 entrées dans son pool de constantes.

La classe ConstantPoolEntry a le format suivant :

ConstantPoolEntry {
  byte tag;
  byte[] info;
}

Le champ tag correspond au type de constante. Pour la JDK 1.4, il existe 11 tags différents, numérotés de 1 à 12 (2 n'étant pas utilisé).

Ces tags peuvent être représentés en Java sous la forme d'une énumération :

public static enum ConstantPoolTag {
  UTF8(1),
  INTEGER(3),
  FLOAT(4),
  LONG(5),
  DOUBLE(6),
  CLASS(7),
  STRING(8),
  FIELDREF(9),
  METHODREF(10),
  INTERFACE_METHODREF(11),
  NAME_AND_TYPE(12);
 
  private int value;
 
  private ConstantPoolTag(int value) {
    this.value = value;
  }
 
  public int getValue() {
    return this.value;
  }
}

Source

Le contenu du tableau d'octets info varie en fonction du type de tag. Nous allons donc créer une classe par type de constantes, avec une classe parente contenant le tag.

public static abstract class ConstantPoolEntry {
  final private int tag;
 
  public ConstantPoolEntry(ConstantPoolTag tag) {
    this.tag = tag.getValue();
  }
}

Source

XII-A-3-a. ConstantUtf8▲

public class ConstantUTF8 {
  int tag = 0x01;
  int length;
  byte[] string;
}

public static class UTF8 extends ConstantPoolEntry {
  final private java.lang.String value;
 
  public UTF8(final java.lang.String value) {
    super(ConstantPoolTag.UTF8);
    this.value = value;
  }
}

XII-A-3-b. ConstantInt et ConstantFloat▲

public class ConstantInt {
  int tag = 0x03;
  int value;
}
 
public class ConstantFloat {
  int tag = 0x04;
  int value;
}

public static class Integer extends ConstantPoolEntry {
  final private int integer;
 
  public Integer(int integer) {
    super(ConstantPoolTag.INTEGER);
    this.integer = integer;
  }
}
 
public static class Float extends ConstantPoolEntry {
  final private float floatValue;
 
  public Float(float floatValue) {
    super(ConstantPoolTag.FLOAT);
    this.floatValue = floatValue;
  }
}

XII-A-3-c. ConstantLong et ConstantDouble▲

public class ConstantLong {
  int tag = 0x05;
  long value;
}
 
public class ConstantDouble {
  int tag = 0x06;
  long value;
}

public static class Long extends ConstantPoolEntry {
  final private long longValue;
 
  public Long(long longValue) {
    super(ConstantPoolTag.LONG);
    this.longValue = longValue;
  }
}
 
public static class Double extends ConstantPoolEntry {
  final private double doubleValue;
 
  public Double(double doubleValue) {
    super(ConstantPoolTag.DOUBLE);
    this.doubleValue = doubleValue;
  }
}

XII-A-3-d. ConstantString▲

ldc "Hello World"

public class ConstantString {
  int tag = 0x08;
  short utf8Index;
}

public static class String extends ConstantPoolEntry {
  final private int utf8Index;
 
  public String(int stringIndex) {
    super(ConstantPoolTag.STRING);
    this.utf8Index = stringIndex;
  }
}

XII-A-3-e. ConstantClass▲

ConstantUTF8

public class ConstantClass {
  int tag = 0x07;
  short utf8Index;
}

public static class Class extends ConstantPoolEntry {
  final private int nameIndex;
 
  public Class(final int nameIndex) {
    super(ConstantPoolTag.CLASS);
    this.nameIndex = nameIndex;
  }
}

XII-A-3-f. Les quatre derniers tags▲

Le champ accessFlags permet d'indiquer l'ensemble des modificateurs d'une classe à l'aide de masques. En d'autres termes chaque bit correspond à un type de modificateur sachant que plusieurs peuvent être utilisés en même temps, mais que certaines combinaisons sont impossibles.

La représentation sur 2 octets est la suivante :

0000 a0b0 00cd 000e

où :

a = 0x0400 = 0000 1000 0000 0000 (ACC_ABSTRACT)
b = 0x0200 = 0000 0010 0000 0000 (ACC_INTERFACE)
c = 0x0020 = 0000 0000 0010 0000 (ACC_SUPER)
d = 0x0010 = 0000 0000 0001 0000 (ACC_FINAL)
e = 0x0001 = 0000 0000 0000 0001 (ACC_PUBLIC)

Quelques règles :

• une interface est distinguée d'une classe à l'aide du flag ACC_INTERFACE ;
• si le flag ACC_INTERFACE est à 1, il doit obligatoirement être accompagné des flags ACC_PUBLIC et ACC_ABSTRACT et les autres ne doivent pas être renseignés ;
• si le flag ACC_INTERFACE est à 0, tous les autres peuvent être utilisés. Néanmoins, les flags ACC_ABSTRACT et ACC_FINAL ne peuvent pas être utilisés en même temps ;
• le flag ACC_SUPER est un artefact du passé lié à l'instruction invokespecial. Tous les nouveaux compilateurs/assembleurs doivent le renseigner.

Dans la version de pjba que nous utilisons actuellement, il est impossible de préciser les modificateurs d'une classe. Le champ accessFlags a pour valeur 0x0021 :

0x0001 | 0x0020 // public super

Le champ thisClass contient l'index de l'objet de type ConstantClass dans le tableau de PoolConstantEntry pointant (par un index dans le tableau de PoolConstantEntry) vers l'objet de type ConstantUtf8 contenant le nom complètement qualifié de la classe.

Le champ superClass contient l'index de l'objet de type ConstantClass dans le tableau de PoolConstantEntry pointant (par un index dans le tableau de PoolConstantEntry) vers l'objet de type ConstantUtf8 contenant le nom complètement qualifié de la classe parente de la classe courante.

En Java, une classe n'héritant pas explicitement (à l'aide du mot clé extends) d'une autre, hérite implicitement de la classe java.lang.Object. Dans un fichier .class tout étant indiqué explicitement, nous aurons toujours une super classe. La seule classe pouvant avoir le champ superClass égal à zéro est la classe Object.

Le champ methodsCount indique le nombre de méthodes définies dans le fichier .class (tout simplement la taille du tableau methods) et le champ methods est un tableau de méthodes de type Method dont la structure peut être représentée de la manière suivante :

public class Method {
  short accessFlags;
  short nameIndex;
  short descriptorIndex;
  short attributesCount;
  Attribute[] attributes;
}

Source

Tout comme le champ accessFlags dans la classe ClassFile, celui-ci permet d'indiquer les modificateurs d'une méthode à l'aide de masques.

Quelques règles :

• une méthode ne peut avoir que l'un des flags suivants à 1 à la fois : ACC_PRIVATE, ACC_PROTECTED ou ACC_PUBLIC ;
• une méthode ayant le flag ACC_ABSTRACT à 1, ne peut avoir aucun des flags suivants : ACC_FINAL, ACC_NATIVE, ACC_PRIVATE, ACC_STATIC, ACC_STRICT, ou ACC_SYNCHRONIZED ;
• une méthode d'interface doit uniquement avoir les flags suivants à 1 : ACC_ABSTRACT et ACC_PUBLIC.

Le champ nameIndex contient l'index de l'objet de type ConstantUtf8 dans le tableau ConstantPoolEntry contenant le nom de la méthode. Par exemple add.

Le champ descriptorIndex contient l'index de l'objet de type ConstantUtf8 dans le tableau ConstantPoolEntry contenant le nom du descripteur de la méthode. Par exemple (I[[Lorg/isk/pjb/Test;Z)V.

Le champ attributesCount indique la taille du tableau attributes et le champ attributes est un tableau de type Attribute dont la structure peut être représentée de la manière suivante :

public class Attribute {
  short nameIndex;
  int attributeLength;
  byte[] info;
}

Source (Dans le code, la classe Attribute est abstraite et n'a pas de champ info.)

L'attribut Code ne peut être présent que dans la structure Method.

L'attribut Code est probablement l'élément le plus important d'un fichier .class puisqu'il contient tous les détails d'implémentation d'une méthode.

Si une méthode est native ou abstraite, l'attribut Code ne doit pas être présent.

public class Code {
  short attributeNameIndex;
  int attributeLength;
  short maxStack;
  short maxLocals;
  int codeLength;
  byte[] code;
  short exceptionsCount;
  Exception[] exceptions;
  short attributesCount;
  Attribute[] attributes;
}

Source (Dans le code, la classe Code hérite de la classe Attribute.)

Les champs suivants ne seront pas décrits dans cet article :

short exceptionsCount;
Exception[] exceptions;
short attributesCount;
Attribute[] attributes;

On considérera que leur champ associé - indiquant la taille des tableaux - aura pour valeur 0.

short exceptionsCount;
short attributesCount;

XII-C-1-a. attributeNameIndex▲

XII-C-1-b. attributeLength▲

2 + 2 + 4 + code.length + 2 + 8 * exceptions.length + 2 + attributes.length

XII-C-1-c. maxStack▲

XII-C-1-d. maxLocals▲

XII-C-1-e. codeLength et code▲