Ereditarietà e passaggio di metodi.

[roquentin]

Ciao a tutti,
vorrei chiedere una cosa riguardante C e JAVA.
In C quando all'interno di una funzione avevo bisogno di un'altra funzione facevo la chiamata alla "sottofunzione" con il passaggio di parametri.
In Java ho notato che esistono dei paradigmi come l'incapsulamento e l'ereditarietà.
Ora la questione è questa: se ho bisogno di chiamare nel metodo2 della classe2, il metodo1 della classe1, nel metodo 2 faccio : classe1.metodo1(parametri).
Ma sapendo appunto dell'esistenza dell'ereditarietà, c'è un modo alternativo per fare questo?
Grazie

[andbin]

Ma sapendo appunto dell'esistenza dell'ereditarietà, c'è un modo alternativo per fare questo?

Alternativo .. in che senso? La invocazione di un metodo è sempre qualcosa tipo:

unRiferimento.nomeMetodoDiIstanza( ... )
oppure
NomeClasse.nomeMetodoDiClasse( ... )

Salvo che unRiferimento e NomeClasse possono essere impliciti se il metodo è già "in scope" nel punto in cui fai la invocazione. E questo ad esempio può capitare se una classe A definisce un metodo di istanza x(), poi una classe B estende A e se non fa l'override di x (e x è "visibile", cioè lo eredita), allora dentro un metodo di istanza di B basta invocare x() che sostanzialmente è l'equivalente di this.x().

[roquentin]

Infatti questo intendevo: l'utilizzo di extends e dell'override, quando è opportuno farlo?
Cosa significa "in scope" ?

[andbin]

Infatti questo intendevo: l'utilizzo di extends e dell'override, quando è opportuno farlo?
Cosa significa "in scope" ?

Ehm ... ce l'hai un libro di testo su Java a portata di mano??

[roquentin]

Si...De Sio Cesari Java 8

[roquentin]

Cioè , ho questa classe

public class ApriFile {

    public static void ApriFiles(File directory) throws FileNotFoundException, IOException {

        FileReader f = new FileReader(directory + "\\Gennaio.txt");
        BufferedReader b = new BufferedReader(f);
        ArrayList<String> gennaio = new ArrayList<>();

        String s = b.readLine();

        while (s != null) {
            gennaio.add(s);
            s = b.readLine();

        }
        for (String i : gennaio) {
            System.out.println(i);
        }

    }
}

ed in questa richiamo il metodo ApriFiles

public class ApriFile {

    public static void ApriFiles(File directory) throws FileNotFoundException, IOException {

        FileReader f = new FileReader(directory + "\\Gennaio.txt");
        BufferedReader b = new BufferedReader(f);
        ArrayList<String> gennaio = new ArrayList<>();

        String s = b.readLine();

        while (s != null) {
            gennaio.add(s);
            s = b.readLine();

        }
        for (String i : gennaio) {
            System.out.println(i);
        }

    }
}

In questo caso posso usare l'estensione ?

[andbin]

ed in questa richiamo il metodo ApriFiles

Mah .. io qui vedo il codice ripetuto due volte.
Verifica cosa hai scritto e magari riposta quello che intendevi.

In questo caso posso usare l'estensione ?

L'ereditarietà serve per definire una relazione di generalizzazione/specializzazione tra due classi. Questa relazione è anche detta con l'espressione "è un" (in inglese "IS-A"). La superclasse è un caso più generale, la sottoclasse è un caso più specifico.

Una classe Gatto può estendere una classe Animale, perché un gatto è un caso più specifico di un animale. Una classe Sfera può estendere la classe Solido (una sfera è un solido). Una classe StudenteUniversitario può estendere la classe Studente che può estendere la classe Persona.

Se non puoi esprimere in modo sensato questa relazione .... l'ereditarietà non ti serve.
Ah, e inoltre, ovviamente non va usata solo perché magari "fa comodo" rendere disponibili dei metodi o campi ad un'altra classe.

[roquentin]

Mah .. io qui vedo il codice ripetuto due volte.
Verifica cosa hai scritto e magari riposta quello che intendevi.


L'ereditarietà serve per definire una relazione di generalizzazione/specializzazione tra due classi. Questa relazione è anche detta con l'espressione "è un" (in inglese "IS-A"). La superclasse è un caso più generale, la sottoclasse è un caso più specifico.

Una classe Gatto può estendere una classe Animale, perché un gatto è un caso più specifico di un animale. Una classe Sfera può estendere la classe Solido (una sfera è un solido). Una classe StudenteUniversitario può estendere la classe Studente che può estendere la classe Persona.

Se non puoi esprimere in modo sensato questa relazione .... l'ereditarietà non ti serve.
Ah, e inoltre, ovviamente non va usata solo perché magari "fa comodo" rendere disponibili dei metodi o campi ad un'altra classe.

Ok capito.
comunque ho sbagliato ad incollare il codice.
le classi sono queste

public class ApriFile {

    public static void ApriFiles(File directory) throws FileNotFoundException, IOException {

        FileReader f = new FileReader(directory + "\\Gennaio.txt");
        BufferedReader b = new BufferedReader(f);
        ArrayList<String> gennaio = new ArrayList<>();

        String s = b.readLine();

        while (s != null) {
            gennaio.add(s);
            s = b.readLine();

        }
        for (String i : gennaio) {
            System.out.println(i);
        }

    }
}

e questa

public class RicercaFile {

    private static boolean foundFolder = false;

    public static void findDirectory(File parentDirectory, String e) throws IOException  {
        
        if(foundFolder){
            return;
        }
        File[] files = parentDirectory.listFiles();
        for (File file : files) {
            if (file.isFile()) {
                continue;
            }
            if (file.getName().equals(e)) {
                foundFolder = true;
                System.out.println(file);
                ApriFile.ApriFiles(file);

            } else {
            }
            if (file.isDirectory()) {
                findDirectory(file, e);
            }

        }
     
    }

}

[andbin]

public class ApriFile {

public class RicercaFile {

L'ereditarietà qui non ci azzecca un bel niente.

[roquentin]

Ok grazie