Discussion :

[Jiinta]

Bonjour,

Dans le cadre de mon stage, je dois développer un code de lecture sur SD via les ports SPI du module TC65i avec lequel je travaille.

J'ai eu dans l'idée d'importer une librairie qui s'occupe de la lecture/écriture dans la FAT pour me faciliter la vie. Le soucis étant que celle librairie a été développée avec une jdk 1.5 et que le module faisant tourner le code est équipé d'une jre 1.4 J2ME.

J'ai donc rencontré plusieurs problèmes, que je n'arrive toujours pas à résoudre :
- les "classes enum" n'existent pas dans la jdk 1.4, de quelle manière pourrais-je les adapter pour obtenir un fonctionnement similaire?
- les "<" ">" ne sont pas permis dans la jdk 1.4, du coup lorsqu'une hashmap est déclarée par exemple, je suis obligé de supprimer ces caractères et ce qu'ils contiennent, c'est à dire l'indication du type d'objets que cette hashmap va contenir. Du coup, bonjour les cast après ... Il n'y aurait pas une solution plus simple?
- lorsque j'implémente une interface, Netbeans me signale que je dois redéfinir toutes les méthodes de cette interface dans ma classe. Jusque-là je suis d'accord, mais le soucis étant que toutes les méthodes de cette interface sont déjà redéfinies dans la classe ... problème de l'IDE ou de compatibilité de la jdk?
- il y'a aussi le problème des "for each loop" qui n'est pas supporté par la jdk 1.4, mais je vous en fais grâce il y'a moyen de bidouiller un peu à mon avis ...

Veuillez m'excuser si les termes utilisés ne sont pas appropriés mais je ne programme pas depuis longtemps en Java.

Merci d'avance

[Heimdal]

Salut,

la migration (ou régression) 1.5 -> 1.4 est particulièrement lourde...
Je vais essayer de répondre aux points que tu soulèves:

les "classes enum" n'existent pas dans la jdk 1.4, de quelle manière pourrais-je les adapter pour obtenir un fonctionnement similaire?

Un fonctionnement similaire ce n'est pas possible, mais très proche ca l'est avec un pattern state.
Ex:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
public enum EnumQqcq {
 
	A, B, C;
 
}

deviendrait:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
public class EnumQqcq {
 
	public final static EnumQqcq A = new EnumQqcq();
	public final static EnumQqcq B = new EnumQqcq();
	public final static EnumQqcq C = new EnumQqcq();
 
	private EnumQqcq() {
	}
 
}

Les "<" ">" ne sont pas permis dans la jdk 1.4, du coup lorsqu'une hashmap est déclarée par exemple, je suis obligé de supprimer ces caractères et ce qu'ils contiennent, c'est à dire l'indication du type d'objets que cette hashmap va contenir. Du coup, bonjour les cast après ... Il n'y aurait pas une solution plus simple?

Non, il n'y a pas d'autres solutions a ma connaissance.

lorsque j'implémente une interface, Netbeans me signale que je dois redéfinir toutes les méthodes de cette interface dans ma classe. Jusque-là je suis d'accord, mais le soucis étant que toutes les méthodes de cette interface sont déjà redéfinies dans la classe ... problème de l'IDE ou de compatibilité de la jdk?

Là, je suis très étonné et je miserai plus sur un problème de synchro de ton IDE. Le build fonctionne-t-il? et avec javac?

il y'a aussi le problème des "for each loop" qui n'est pas supporté par la jdk 1.4, mais je vous en fais grâce il y'a moyen de bidouiller un peu à mon avis

Il faudra plutot utiliser les boucles avec iterator()...

Voili, voilou...
Tiens nous au jus.
A+

[Jiinta]

Merci pour tes réponses

En ce qui concerne le problème avec l'implémentation des méthodes de l'interface, j'ai trouvé l'erreur, c'est en fait le retour d'une des méthodes qui est "override" qui pose problème :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
    public IBMPartitionTable getChildPartitionTable() {
        throw new Error("Not implemented yet");
    }

Apparement ca devait être accepté tel quel sous jdk 1.5 mais pas 1.4.

Je pense que vu que la méthode n'est de tout de façon pas encore utilisée j'ai juste à mettre un retour null et ce problème sera corrigé.

Merci encore pour ton aide!

[Jiinta]

Je reviens vers vous car un nouveau problème se pose avec une enum :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
enum FatType {
 
    /**
     * For a 12-bit file allocation table.
     */
    FAT12((1 << 12) - 16, 0xFFFL, 1.5f, "FAT12   ") {
 
        //@Override
        public long readEntry(byte[] data, int index) {
            final int idx = (int) (index * 1.5);
            final int b1 = data[idx] & 0xFF;
            final int b2 = data[idx + 1] & 0xFF;
            final int v = (b2 << 8) | b1;
 
            if ((index % 2) == 0) {
                return v & 0xFFF;
            } else {
                return v >> 4;
            }
        }
 
        //@Override
        public void writeEntry(byte[] data, int index, long entry) {
            final int idx = (int) (index * 1.5);
 
            if ((index % 2) == 0) {
                data[idx] = (byte) (entry & 0xFF);
                data[idx + 1] = (byte) ((entry >> 8) & 0x0F);
            } else {
                data[idx] |= (byte) ((entry & 0x0F) << 4);
                data[idx + 1] = (byte) ((entry >> 4) & 0xFF);
            }
        }
    },
 
    /**
     * For a 16-bit file allocation table.
     */
    FAT16((1 << 16) - 16, 0xFFFFL, 2.0f, "FAT16   ") {
 
        //@Override
        public long readEntry(byte[] data, int index) {
            final int idx = index << 1;
            final int b1 = data[idx] & 0xFF;
            final int b2 = data[idx + 1] & 0xFF;
            return (b2 << 8) | b1;
        }
 
        //@Override
        public void writeEntry(byte[] data, int index, long entry) {
            final int idx = index << 1;
            data[idx] = (byte) (entry & 0xFF);
            data[idx + 1] = (byte) ((entry >> 8) & 0xFF);
        }
    }

le constructeur de la classe étant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
    private FatType(int maxClusters,
            long bitMask, float entrySize, String label) {
 
        this.minReservedEntry = (0xFFFFFF0L & bitMask);
        this.maxReservedEntry = (0xFFFFFF6L & bitMask);
        this.eofCluster = (0xFFFFFF8L & bitMask);
        this.eofMarker = (0xFFFFFFFL & bitMask);
        this.entrySize = entrySize;
        this.label = label;
        this.maxClusters = maxClusters;
        this.bitMask = bitMask;
    }

Donc, si j'ai bien compris, les méthodes sont "override" en fonction de l'objet FAT12 ou FAT16, qui est lui même une instance de sa propre classe ...

Maintenant, si je modifie mon enum en class et que je définis FAT12 et FAT16 en tant que public final static le soucis est que je n'ai plus l'opportunité de redéfinir les méthodes pour chacun d'eux séparément ...

Peut-être dois-je recréer FAT12 et FAT16 en tant que class à part dans lesquelles je pourrai "override" tranquillement leur méthodes, mais ca me semble un peu trop s'éloigner de la solution de base de l'auteur ...

Une idée?

[Heimdal]

Salut,

il faut faire un truc du genre. Le mieux serait que ces classes soient seules dans leur package afin d'éviter que l'on puisse accéder aux différents constructeurs.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
public abstract class ParentType {
 
	public static final ParentType TYPE1 = new SpecificType1("type1", 1);
	public static final ParentType TYPE2 = new SpecificType2("type2", 2);
 
	private final String attribute1;
	private final int attribute2;
 
	ParentType(String arg1, int arg2) {
		this.attribute1 = arg1;
		this.attribute2 = arg2;
	}
 
	public abstract void method1();
 
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
class SpecificType1 extends ParentType{
 
	SpecificType1(String arg1, int arg2) {
		super(arg1, arg2);
	}
 
	public void method1() {
		//ta methode specifique
	}
 
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
class SpecificType2 extends ParentType {
 
	SpecificType2(String arg1, int arg2) {
		super(arg1, arg2);
	}
 
	public void method1() {
		//ta methode specifique
		System.out.println("type2");
	}
 
}

Les clauses de visibilité sont très importantes...