Query su come nascondere i dettagli di implementazione in java

1

Con il codice sottostante relativo al thread, vedo che l'autore di Thread class nasconde i dettagli sul funzionamento del metodo start() . Quello che un utente della classe Thread deve sapere è che class Thread si aspetterebbe un pezzo del suo codice che sarà un'istanza della sottoclasse concreta anonima di Runnable che viene superata.

/* TestThread.java */
public class TestThread{

    public static void main(String[] args){
    Thread threadObject = new Thread(new Runnable(){
        public void run(){
           /* your own code that has to run*/   
           System.out.println("a new thread");
        }
    }); 
    threadObject.start();
    System.out.println("Main thread");
    }
}

Ma in questo sotto programma, sembra che nascondiamo parzialmente i dettagli di implementazione del metodo listFiles(filter) . Perché se l'autore deve cambiare la logica di listFiles(filter) in futuro senza influenzare gli utenti, deve assicurarsi che la firma del metodo boolean accept(File dir, String name); non venga influenzata.

/* ListDirectoryWithFilter.java */

import java.io.File;
import java.io.FilenameFilter;

public class ListDirectoryWithFilter{
    public static void main(String[] args){
        String path = System.getProperty("user.home") + File.separator + "workspace" + 
                                            File.separator + "JavaCode" + File.separator + "src";
        File dir = new File(path);

        if(dir.isDirectory()){
            File[] files = dir.listFiles(new FilenameFilter(){
                public boolean accept(File dir, String file){
                    return file.endsWith(".java");
                }
            });
            for(File file : files){
                System.out.println(file.getName());
            }
        }
    }
}

Pensi che sarebbe stato meglio che il metodo listFiles(filter) aspettasse solo un'espressione regolare ( *.java ) da parte dell'utente e il resto è il risultato che l'utente si aspetta?

Sembrava un approccio un po 'inutile per me, per implementare un metodo di due argomenti accept(,) e poi passarlo al metodo listFiles() .

Quindi, tali implementazioni sono una buona pratica? Se sì, quando pensiamo a tali implementazioni?

    
posta overexchange 20.12.2014 - 10:59
fonte

2 risposte

3

Sì, è una buona pratica. Sembra un po 'standard e strano, perché Java 7 e versioni precedenti non supportano molto bene la programmazione funzionale.

La differenza rispetto a un'espressione regolare è che un'espressione regolare limita le opzioni per filtrare i file. Per esempio. diciamo che vuoi filtrare i file non solo con il loro nome ma [solo / in aggiunta] con il loro contenuto o altri metadati (in futuro). Quindi, le espressioni regolari sono insufficienti per fare ciò. Inoltre, possono essere piuttosto lenti e una regex dannosa potrebbe addirittura interrompere il programma se non si utilizzano tecniche per evitare che impieghi un sacco di tempo per eseguire l'espressione regolare.

Per spiegarlo in modo più generale: che cosa vuoi fare? Vuoi filtrare i file di una directory. Questo è tutto. Non di più, non di meno. Non riesco a leggere nulla delle espressioni regolari in questa spiegazione, quindi non dovrebbero essere usati. Dovrebbe essere usato un approccio generale al filtro che include la possibilità di usare espressioni regolari ma non lo limita alle espressioni regolari.

    
risposta data 20.12.2014 - 12:07
fonte
0

Questa API è meno di nascondere i dettagli di implementazione e di più sul rinvio al programmatore per le parti interessanti dell'azione.

listFiles() sa come eseguire iterazioni sui file in una directory e restituire un sottoinsieme di essi. Thread sa come eseguire codice in parallelo al codice attualmente in esecuzione. Tuttavia, dal punto di vista dell'applicazione, quelle sono le parti noiose. Le parti interessanti sono la decisione di includere un file e il codice reale che viene eseguito in parallelo. Prendendo un'interfaccia funzionale (un concetto formalizzato in Java 8), queste implementazioni fanno esattamente ciò di cui hanno bisogno e non di più. Il programmatore che chiama questi metodi sa esattamente come implementare le parti interessanti. Questo stile di API offre al programmatore la flessibilità di fare ciò che vuole, anche se potrebbe essere più complesso dei casi più comuni.

    
risposta data 20.12.2014 - 12:35
fonte

Leggi altre domande sui tag