Bonjour à tous,

J'ai créé une méthode dans une interface qui va lire dans une liste de chemins (path) dans un autre fichier "enum" qui s'appelle CheminsBin et qui renvoie le bon chemin.

Fallait-il créer une interface ou un autre type de classe?

Voici le fichier "interface"

package fr.marcharnist.filecrud;

import java.io.File;

interface CheminBin {
	
	static String trouveCheminBin() {
		// TODO Auto-generated method stub

		/** Vérifie le PC
		 *  Le programme ne fonctionne pas si le chemin du bureau change lorsqu'on change de PC
		 *  C'est pour cela que le chemin a été coupé et s'arrête au Desktop pour vérifications.
		 * 	
		 * Model:     for(Langage lang : Langage.values()){	
		 */
		for(CheminsBin path: CheminsBin.values()) {
			File desktopPathVerify = new File(path.toString());
			String dir = null;
			if(desktopPathVerify.exists())
				dir = path.toString();
			return dir;
		}
		return "";
	}
}

Le fichier d'énumération:

package fr.marcharnist.filecrud;

public enum CheminsBin {
	
	BinCMD("fr/marcharnist/filecrud"),
	BinEclipse("bin/fr/marcharnist/filecrud");
	
	private String path;
	
	CheminsBin(String path){
			
		this.path = path;
	}
		
	public String toString() {
		return path;
	}
}

-
Edité par MarcHarnist 15 mai 2019 à 14:26:32

Bonsoir,

Pour faire simple, une interface permet de créer un standard pour les classes qui l'implémenteront. Comme dans le cours, on admet qu'un Chien et un chat sont des animaux. Mais on est d'accord pour dire qu'un chien ou un chat ne cri pas pareil et ne se déplace pas pareil mais les deux le font !

De ce fait, on créé une interface Animal, qui va définir des méthodes crier() et deplacement(). Cela créé notre standard de fonctionnement d'un Animal.

Maintenant on peut dire qu'un Chien est un Animal, il va donc implémenter l'interface Animal et a nous de définir comment un chien peut crier() et faire un déplacement(). Idem pour le chat.

Pour résumer :

public interface Animal{
    //On défini le standard
    public void crier();
    public void deplacement();
}

public class Chien implements Animal{
    //Maintenant on spécifie les méthodes
    public void crier(){
        System.out.println("Aboyer");
    }

    public void deplacement(){
        System.out.println("Je cours vite");
    }
}

public class Chat implements Animal{
    //Maintenant on spécifie les méthodes
    public void crier(){
        System.out.println("Je miaule");
    }

    public void deplacement(){
        System.out.println("Je ne me déplace pas, je dors");
    }
}

Et maintenant, on peut les utiliser de la sorte :

Animal monAnimal1 = new Chien();
Animal monAnimal2 = new Chat();

monAnimal1.crier();
//Aboyer
monAnimal2.crier();
//Je miaule

Ce qu'on en retient :

• Une interface défini un standard pour les classes qui l'implémenteront
• Elle permet de définir un "modèle de fonctionnement", de forcer la spécialisation de certaines fonctions
• Ce n'est pas pareil qu'une classe abstraite ou une classe non abstraite (encore moins)

J'ai survolé très fort pour le coup, certains diront que c'est plus complexe, c'est vrai. Et je t'invite à revoir les textes du cours.

Maintenant, dois-tu créer une classe ou une interface ? Et bien pour ça je t'invite à voir comment sont implémenter les fonctionnements de ce genre dans le code source de Java. Particulièrement les fichiers Arrays.java et Strings.java. Package java.util.

Que mes camarades de OpenClassrooms qui ont plus de détails viennent me contredire ou ajouter des infos utiles, j'en apprendrai surement aussi.

Merci!

Bonne révision!

J'ai créé des interfaces pour les fonctions récurrentes: trouver le chemin du bureau de mon Pc, trouver le chemin du répertoire "bin" etc.

Marc

Alors je savais pas que c'était possible en java mais en php il est impossible d'y mettre du code dans une fonction d'une interface.

Pour pallier à ça le php propose les "traits" qui permettent une sorte d'héritage horizontal. Je préfère laisser des spécialistes java répondre sur comment le faire mais ça m'étonne que java autorise ceci pour une interface.

Bonjour,

Ce n'est pas autorisé, du moins, conventionnellement. Je n'ai jamais essayé. Cela dit, il me semble que l'on n'est pas autorisé à le faire pour la simple est bonne raison que ça n'a pas de sens de le faire.

Cela dit il y a un cas où l'on peut le faire, et c'est grâce au mot-clef "default", exemple :

public default void ecrire(){
    System.out.println("Ecrire");
{

Ce mot clé permet aux classes qui implémentent l'interface, de ne pas avoir à implémenter la méthode qui est marquée "default". On le retrouve notamment dans le code source Java, pour la fonction Collection#removeIf (Collection étant une interface) :

default boolean removeIf(Predicate<? super E> filter) {
        Objects.requireNonNull(filter);
        boolean removed = false;
        final Iterator<E> each = iterator();
        while (each.hasNext()) {
            if (filter.test(each.next())) {
                each.remove();
                removed = true;
            }
        }
        return removed;
    }

Et on voit bien que les classes qui l'implémente (quand on cherche) ne redéfinissent pas la fonction removeIf. Mais on peut toujours l'override par l'instruction @Override .

D'autres problèmes peuvent survenir, notamment si on nomme deux méthodes avec le même nom dans deux interfaces différentes et qu'ensuite on cherche à appeler cette méthode dans la classe qui les implémente toutes les deux. Mais là, je vous renvoi vers Internet, il y a plein d'articles.