Scrivere codice, a mio parere, di solito comporta 2 tipi di codice: codice logico e funzionale.
Sebbene la parte logica del codice differisca sempre tra ogni app e i suoi obiettivi, spesso la parte funzionale non cambia molto (specialmente il codice funzionale semplice di basso livello) ed è spesso riutilizzata nello stesso progetto.
Ad esempio, nella mia app uso molto codice relativo al file. Così ho creato una classe util dedicata in questo modo:
public final class FileUtils {
/* Constants */
private static int DEFAULT_BUFFER_SIZE = 1024;
public static final String PACKAGE_FILES_DIR = MyApplication.getContext().getFilesDir().getAbsolutePath(); // Usually: /data/data/package name/files
public static final String MAIN_LOCAL_STORAGE = Environment.getExternalStorageDirectory().getAbsolutePath(); // Usually:
/*
* ================
* Constructor
* ================
*/
private FileUtils() {}
/*
* ================
* Helper methods
* ================
*/
/**
* Write text to file.
* <a>{@see javadoc at the beginning of this class}</a>
*
* @param path the path
* @param fileName the file name
* @param text the text
*/
public static void writeTextToFile(String path, String fileName, String text) {
File file = new File(path, fileName.toString());
try {
file.createNewFile();
FileOutputStream fos = new FileOutputStream(file);
OutputStreamWriter outputStreamWriter = new OutputStreamWriter(fos, "UTF-8");
Writer out = new BufferedWriter(new OutputStreamWriter(fos, "UTF-8"));
out.write(text.toString());
out.close();
fos.close();
outputStreamWriter.close();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* Check and create sub dierctory.
* <a>{@see javadoc at the beginning of this class}</a>
*
* @param path the path
* @param folderName the folder name
*/
public static void checkAndCreateSubDierctory(String path, String folderName) {
// Check and if needed, create logs subdirectory
File subDir = new File(path, folderName);
if (!subDir.exists()) {
subDir.mkdir();
}
}
public static void createZip(){
// create a zip including several files
}
}
Il fatto è che non ho visto molto codice scritto in questo modo. I pro ei contro che vedo in questo approccio sono:
Pro:
-
Rende la parte logica del codice molto più chiara
-
Il codice funzionale non viene riscritto ed è accessibile ovunque
- Per quanto ne so, il punto di
staticè un codice che non ha bisogno di essere istanziato ed è comune a tutti.
Aspetti negativi:
- Può causare una quantità enorme di codice statico.
Un altro approccio possibile sarebbe:
public class FileUtils {
/* Constants */
private static int DEFAULT_BUFFER_SIZE = 1024;
public static final String PACKAGE_FILES_DIR = MyApplication.getContext().getFilesDir().getAbsolutePath(); // Usually: /data/data/package name/files
public static final String MAIN_LOCAL_STORAGE = Environment.getExternalStorageDirectory().getAbsolutePath(); // Usually:
/*
* ================
* Helper methods
* ================
*/
/**
* Write text to file.
* <a>{@see javadoc at the beginning of this class}</a>
*
* @param path the path
* @param fileName the file name
* @param text the text
*/
public void writeTextToFile(String path, String fileName, String text) {
File file = new File(path, fileName.toString());
try {
file.createNewFile();
FileOutputStream fos = new FileOutputStream(file);
OutputStreamWriter outputStreamWriter = new OutputStreamWriter(fos, "UTF-8");
Writer out = new BufferedWriter(new OutputStreamWriter(fos, "UTF-8"));
out.write(text.toString());
out.close();
fos.close();
outputStreamWriter.close();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* Check and create sub dierctory.
* <a>{@see javadoc at the beginning of this class}</a>
*
* @param path the path
* @param folderName the folder name
*/
public void checkAndCreateSubDierctory(String path, String folderName) {
// Check and if needed, create logs subdirectory
File subDir = new File(path, folderName);
if (!subDir.exists()) {
subDir.mkdir();
}
}
public void createZip(){}
}
Pro:
- Non usa il codice statico
Aspetti negativi:
- Ogni volta che vorrei usare il codice, avrei bisogno di istanziare la classe, qualcosa che potrebbe portare alla creazione di molti oggetti
Naturalmente, c'è sempre l'opzione di scrivere il codice localmente in ogni classe, ma che a mia conoscenza viola anche i principi OOP e porta a una maggiore quantità di codice che potrebbe essere salvato ...
Ho cercato molto su questo argomento e non sono riuscito a trovare risposte o approcci concreti.
È un approccio accettabile alla programmazione orientata agli oggetti?
Qualcuno può spiegare perché e quali sono le alternative a questo approccio?