[JAVA] Creazione File

[Vincent79]

Ragazzi sto cercando di imparare i primi passi di java e stavo cercando di creare un nuovo file su disco...
solo che quando utilizzo il codice, che vi posto tra poco, il software (utilizzo eclipse) mi da errore...
cosa sbaglio???

Codice

import java.io.*;
public class NameFile {
public static void main(String[] arg) throws Exception {
File f;
f = new File("Ciao");
}
}

[wizard1993]

che errore? Non ho compilatore sotto mano

[Vincent79]

Allora questo codice dovrebbe crearmi un file di nome "Ciao" nella mia cartella di lavoro...
giusto???

se così dovrebbe, perchè non trovo nessun file creato???

[Vincent79]

Ora posto un codice un pò più complesso che mi segnala questo errore
FileInputStream.open(String) line: not available [native method]

questo invece è il codice
import java.io.*;
public class CreaFile1 {
public static void main(String[] arg) throws Exception {
String fileName, line1;
BufferedReader keyBR, fBR;
PrintStream ps;
ps = System.out;

ps.print("Inserisci il nome del file ");

keyBR = new BufferedReader(new InputStreamReader(System.in));
fileName = keyBR.readLine();

fBR = new BufferedReader(new InputStreamReader (new FileInputStream (new File (fileName))));
line1 = fBR.readLine();
ps.print(line1);
}
}

[ingframin]

Stai cercando di leggere un file che non esiste.
Devi usare FileOutputStream per scrivere su file, non FileInputStream.
Poi ricorda di chiudere il file alla fine, altrimenti non e' detto che venga scritto su disco.
BufferedReader serve per leggere da un file non per scriverci su.
Per scrivere su file serve BufferedWriter.
http://javadb.com/write-to-file-using-bufferedwriter
Qui c'e' un bell'esempio.

[banryu79]

Consiglio la lettura di questa trail dei Java Tutorials: Lesson: Basic I/O (docs.oracle.com/javase/tutorial/essential/io/index.html)

[Vincent79]

Grazie mille...
avevo trovato la soluzione ieri sera all'una...:sofico:
quindi il Buffered serve per gestire un flusso di dati,
FileInput in ingresso
FileOutput in uscita!!!

[Vincent79]

[QUOTE=ingframin;37747498]Poi ricorda di chiudere il file alla fine, altrimenti non e' detto che venga scritto su disco.
QUOTE]

come faccio a chiudere il file alla fine???

[ingframin]

bufferedWriter.flush();
bufferedWriter.close();

[Vincent79]

Ragazzi ma se posto qualche traccia di esercizi base (che ho già svolto e funzionano) qualcuno può svilupparli, così da fare un confronto???

PS: chiedo prima di intasare il forum...

[Vincent79]

Ho questo pezzo di codice

public String OraData(String newData, String newOra)
{
ora = newOra;
data = newData;
System.out.println("La nuova data è " + data);
System.out.println("Appuntamento fissato per le " + ora);
return null;
}

che tipo di variabile devo assegnare a return, dato che il metodo ha due parametri???

[banryu79]

Ho questo pezzo di codice


...
public String OraData(String newData, String newOra) {
ora = newOra;
data = newData;
System.out.println("La nuova data è " + data);
System.out.println("Appuntamento fissato per le " + ora);
return null;
}
...


che tipo di variabile devo assegnare a return, dato che il metodo ha due parametri???
Dipende dalla semantica del metodo e della classe di cui fa parte.
Cosa rasppresenta quella classe? Quali responsabilità ha? E cosa ci si aspetta come valore di ritorno quando si invoca il metodo OraData su un'istanza di quella classe?

[Vincent79]

Dipende dalla semantica del metodo e della classe di cui fa parte.
Cosa rasppresenta quella classe? Quali responsabilità ha? E cosa ci si aspetta come valore di ritorno quando si invoca il metodo OraData su un'istanza di quella classe?

L'esercizio mi dice di creare una classe che specifica un appuntamento, compreso di data, ora e luogo, con rispettive modifiche...
per cui direi che il metodo deve restituire una nuova data ed un nuovo orario in formato String (me lo specifica la traccia)...

[banryu79]

L'esercizio mi dice di creare una classe che specifica un appuntamento, compreso di data, ora e luogo, con rispettive modifiche...
per cui direi che il metodo deve restituire una nuova data ed un nuovo orario in formato String (me lo specifica la traccia)...
Puoi postare il testo completo dell'esercizio?

[Vincent79]

Puoi postare il testo completo dell'esercizio?

Certo:
Scrivere una classe Appointment che modelli un appuntamento
comportamento:
Ottenere la descrizione dell'app.
modificare la descrizione dell'app.
ottenere la data e l'orario dell'app. come oggetto String
modificare la data e l'orario dell'app.
ottenere il luogo dell'app. come oggetto String
modificare il luogo dell'app.

[banryu79]

Certo:
Scrivere una classe Appointment che modelli un appuntamento
comportamento:
Ottenere la descrizione dell'app.
modificare la descrizione dell'app.
ottenere la data e l'orario dell'app. come oggetto String
modificare la data e l'orario dell'app.
ottenere il luogo dell'app. come oggetto String
modificare il luogo dell'app.
Leggendo il testo della consegna, ho identificato le diverse parti evidenziate.
Ricapitolando: Appuntamento è un oggetto costituito da una Descrizione, una Data, un Orario e un Luogo. La consegna ci dice anche che un Appuntamento è mutabile in tutte le sue parti costituenti (i vari: "modificare la descrizione...", "modificare la data e l'orario", ecc...)

La consegna stabilisce anche alcuni vincoli circa l'implementazione:
1) dice che Appuntamento è una classe;
2) che per ognuna delle parti costituenti deve esistere un metodo per ottenere la parte stessa rappresentata, in particole per data, ora e luogo il metodo deve restituire una String;
3) che per ognuna delle parti costituenti (descrizione,data,ora,luogo) deve esistere un metodo per mutarla.

Notiamo anche che la consegna non stabilisce come debbano essere fatte le parti costituenti, dice solo che per alcune di esse i metodi per ottenerle devono restituire una String. Questo ultimo dettaglio è rilevante, perchè ci lascia un certo grado di libertà nel scegliere come implementare ogni parte costituente.

Ora, come prima cosa possiamo provare a scrivere la lista dei campi di Appuntamento e la lista dei suoi metodi, così come richiesti dal testo dell'esercizio, tanto per vedere se l'analisi fin qui fatta fila, oppure se mancano dei tasselli:

Appuntamento
- Descrizione
- Data
- Ora
- Luogo
+ getDescrizione() => Descrizione
+ setDescrizione(Descrizione) => void
+ getData() => String
+ setData(Data) => void
+ getOrario() => String
+ setOrario(Orario) => void
+ getLuogo() => String
+ setLuogo(Luogo) => void

Per prima cosa: tenendo conto della consegna, l'interfaccia (insieme dei metodi pubblici) di Aricolo è corretta e completa? Servono più metodi? Meno? Qualcosa va cambiato o va bene così?

[Vincent79]

Leggendo il testo della consegna, ho identificato le diverse parti evidenziate.
Ricapitolando: Appuntamento è un oggetto costituito da una Descrizione, una Data, un Orario e un Luogo. La consegna ci dice anche che un Appuntamento è mutabile in tutte le sue parti costituenti (i vari: "modificare la descrizione...", "modificare la data e l'orario", ecc...)

La consegna stabilisce anche alcuni vincoli circa l'implementazione:
1) dice che Appuntamento è una classe;
2) che per ognuna delle parti costituenti deve esistere un metodo per ottenere la parte stessa rappresentata, in particole per data, ora e luogo il metodo deve restituire una String;
3) che per ognuna delle parti costituenti (descrizione,data,ora,luogo) deve esistere un metodo per mutarla.

Notiamo anche che la consegna non stabilisce di che tipo debbano essere le parti costituenti, dice solo che per alcune di esse i metodi per ottenerle devono restituire una String. Questo ultimo dettaglio è rilevante, perchè ci lascia un certo grado di libertà nel scegliere come implementare ogni parte costituente.

Ora, come prima cosa possiamo provare a scrivere la lista dei campi di Appuntamento e la lista dei suoi metodi, così come richiesti dal testo dell'esercizio, tanto per vedere se l'analisi fin qui fatta fila, oppure se mancano dei tasselli:

Appuntamento
- Descrizione
- Data
- Ora
- Luogo
+ getDescrizione() => Descrizione
+ setDescrizione(Descrizione) => void
+ getData() => String
+ setData(Data) => void
+ getOrario() => String
+ setOrario(Orario) => void
+ getLuogo() => String
+ setLuogo(Luogo) => void

Per prima cosa: tenendo conto della consegna, l'interfaccia (insieme dei metodi pubblici) di Aricolo è corretta e completa? Servono più metodi? Meno? Qualcosa va cambiato o va bene così?

Ora ti posto il codice che ho sviluppato io:
public class Appointment {
public Appointment() {
description = "Vendita Appartamento";
data = "03-08-2012";
ora = "12:30";
luogo = "Firenze";
System.out.println("OGGETTO: " + description + ", data " + data + ", ora " + ora + ", luogo " + luogo);
}

public String description(String newDescription)
{
description = newDescription;
System.out.println("OGGETTO - " + description);
return description;
}

public String OraData(String newData, String newOra)
{
ora = newOra;
data = newData;
System.out.println("La nuova data è " + data);
System.out.println("Appuntamento fissato per le " + ora);
return null;
}

public String luogo(String newLuogo)
{
luogo = newLuogo;
System.out.print(luogo + " è il luogo dell'incontro!");
return luogo;
}

private String data, ora, luogo;
private String description;

}

e questo invece è il codice di prova:
import java.io.*;
public class TryAppointment {
public static void main(String[] arg) throws Exception {
BufferedReader br;
br = new BufferedReader(new InputStreamReader(System.in));

String newDescription, newOra, newData, newLuogo;
Appointment app;
app = new Appointment();
System.out.print("Digita la nuova descrizione ");
newDescription = br.readLine();
System.out.print("Digita la nuova data ");
newData = br.readLine();
System.out.print("Digita la nuova ora ");
newOra = br.readLine();
System.out.print("Digita il nuovo luogo ");
newLuogo = br.readLine();
app.description(newDescription);
app.OraData(newData, newOra);
app.luogo(newLuogo);
}

}

Il programma sembra funzionare...

[Vincent79]

Concetto che non riesce a capire sono l'utilizzo del this e poi la restituzione di un metodo, come faccio a definire cosa deve restituire???

[banryu79]

Concetto che non riesce a capire sono l'utilizzo del this e poi la restituzione di un metodo, come faccio a definire cosa deve restituire???
Il this è il puntatore implicito all'istanza.
Ad esempio, se ho questa classe:

class Persona {
String nome;
String cognome;

Persona(String nome, String cognome) {
this.nome = nome;
this.cognome = cognome;
}
}

quando ne creo un'istanza invocandone il costruttore:

Persona marco = new Persona("Marco", "Guerrini");

all'interno del costruttore, dire "this.nome" significa fare riferimento al campo di istanza mentre invece dire "nome" significa fare riferimento al parametro del costruttore. Questi sono concetti base del linguaggio: ti consiglio questo tutorial per ripassare: http://docs.oracle.com/javase/tutorial/java/javaOO/index.html oppure fai riferimento al tuo testo.


Per quanto riguarda il come definire cosa deve essere restituito da un metodo della classe di cui parlavamo prima, stavo appunto cercando di spiegarti con un esempio diretto che di solito uno fa prima un'analisi dei requisiti: prima di scrivere il codice che implementa la soluzione è neccessario definire la soluzione stessa il più esattamente possibile.
Prova a riesaminare la piccola analisi che ti ho proposto sopra (perchè non è detto che sia corretta) e a rispondere alla domanda che ti ho posto alla fine, perchè tale risposta ci porta più vicini alla definizione di una soluzione per il tuo esercizio.

[Vincent79]

Il this è il puntatore implicito all'istanza.
Ad esempio, se ho questa classe:

class Persona {
String nome;
String cognome;

Persona(String nome, String cognome) {
this.nome = nome;
this.cognome = cognome;
}
}

quando ne creo un'istanza invocandone il costruttore:

Persona marco = new Persona("Marco", "Guerrini");

all'interno del costruttore, dire "this.nome" significa fare riferimento al campo di istanza mentre invece dire "nome" significa fare riferimento al parametro del costruttore. Questi sono concetti base del linguaggio: ti consiglio questo tutorial per ripassare: http://docs.oracle.com/javase/tutorial/java/javaOO/index.html oppure fai riferimento al tuo testo.


Per quanto riguarda il come definire cosa deve essere restituito da un metodo della classe di cui parlavamo prima, stavo appunto cercando di spiegarti con un esempio diretto che di solito uno fa prima un'analisi dei requisiti: prima di scrivere il codice che implementa la soluzione è neccessario definire la soluzione stessa il più esattamente possibile.
Prova a riesaminare la piccola analisi che ti ho proposto sopra (perchè non è detto che sia corretta) e a rispondere alla domanda che ti ho posto alla fine, perchè tale risposta ci porta più vicini alla definizione di una soluzione per il tuo esercizio.

Per quanto riguarda il this, in pratica, quando utilizzo
this.nome = nome;
this.cognome = cognome;
che cosa avviene...???

rispondendo alla tua domanda, credo che la tua analisi sia corretta e che non vi vogliano ulteriori metodi, visto che soddisfano tutte le richieste della traccia...
se ho capito bene la tua domanda!!!

[Vincent79]

Ad esempio ora ho un atrlo esercizio, nel quale devo sviluppare una classe Pubblicazione, con metodi String titolo e autore, e metodi int con numero di pagine e prezzo di copertina; infine vuole un altro metodo toString che restituisca una stringa con i dati dell'oggetto su cui è invocato...
quest'ultima richiesta dovrebbe essere svolta così:

public String toString(String s)
{
...
return s;
}

PS: ... devo sostuirci il codice da sviluppare

[Vincent79]

Ho buttato giù una bozza, seguendo il tuo esempio

Pubblicazione
- Titolo
- Autore
- Numero di pagine
- Prezzo di copertina
+ getTitolo() => String
+ setTitolo(Titolo) => void
+ getAutore() => String
+ setAutore(Autore) => void
+ getPrezzo() => int
+ setPrezzo(Prezzo) => void
+ getPagine() => int
+ setPagine(Pagina) => void
+ toString(String) => String

[banryu79]

Partiamo dal presupposto che tu conosca la differenza tra i diversi generi di variabili, in Java:
Instance Variables (Non-Static Fields)
Class Variables (Static Fields)
Local Variables
Parameters
Le spiegazioni si trovano in questa pagina.
(http://docs.oracle.com/javase/tutorial/java/nutsandbolts/variables.html)

In Java, this è una delle keyword del linguaggio.

1)
Il this è un riferimento all'istanza della classe in cui compare. In quanto tale, può essere usato per accedere ai campi di quell'istanza (Instance Variables) e ai metodi di quell'istanza.
Ho cecato di illustrarti questo uso del this nel mio post di prima, dove this viene usato dentro il costruttore di Persona per distinguere l'accesso al campo di istanza 'nome' dal parametro (Parameters) 'nome' del costruttore.
In pratica risolve l'ambiguità locale al costruttore di Persona data dal fatto che esiste sia un campo di istanza di nome 'nome' che un parametro del costruttore di nome 'nome': ci troviamo di fronte a due entità diverse (una è un campo della classe Persona, l'altra un parametro del costruttore) che hanno lo stesso nome. L'uso del this risolve questa ambiguità.

2)
Il this, sempre in quanto riferimento all'istanza della classe in cui compare, può essere passato come argomento ad un metodo.
Ad esempio:

class Persona {
String nome;
String cognome;
...

Persona(String nome, String cognome) {
this.nome = nome;
this.cognome = cognome;
}

void firma(Documento doc) {
doc.aggiungiFirma(this);
}
}

interface Documento {
...
public void aggiungiFirma(Persona firmatario) {...}
...
}


3)
Il this può anche essere usato in un costruttore della classe per eseguire una chamata ad un'altro costruttore. Ad esempio:

class Persona {
String nome;
String cognome;
int figli;

Persona(String nome, String cognome) {
this(nome, cognome, 0);
}

Persona(String nome, String cognome, int figli) {
this.nome = nome;
this.cognome = cognome;
this.figli = figli;
}
}


Per spiegazioni più puntuali puoi consultare questa pagina (http://docs.oracle.com/javase/tutorial/java/javaOO/thiskey.html).
Io, in particolare, ti consiglio di leggere tutto il tutorial (http://docs.oracle.com/javase/tutorial/java/javaOO/index.html).

[Vincent79]

Diciamo che le cose cominciano ad essere un pò più chiare!!!
In effetti l'utilizzo del this avviene prevalentemente quando ci sono due variabili con la stessa dicitura in punti differenti di una classe...
scusami non sarebbe più facile cambiare il nome alla variabile???

public class Anno(int età) {
età = 16;
}

public int getAnno(int età)
{
this.età = newEtà;
return età;
}

questo esempio, che ho appena inventato, mi fa capire che il this fa riferimento alla varibile del metodo getAnno e non a quella della classe, giusto???

Scusami se faccio tutte queste domande che sembrano banali, ma senza questi chairimenti credo di non riuscire ad andare avanti nell'apprendimento...

[banryu79]

public class Anno(int età) {
età = 16;
}

public int getAnno(int età)
{
this.età = newEtà;
return età;
}

questo esempio, che ho appena inventato, mi fa capire che il this fa riferimento alla varibile del metodo getAnno e non a quella della classe, giusto???

Non riesco a capire il tuo esempio:
1 - se Anno è, nelle tue intenzioni, una classe, quel pseudocodice Java cosa fa? Dichiara la classe e al contempo il costruttore? Quindi, in quel contesto, 'età' è un campo della classe?
2 - Il metodo getAnno cosa dovrebbe fare? Non riesco a capirlo. Inoltre, newEtà da dove salta fuori?


Scusami se faccio tutte queste domande che sembrano banali, ma senza questi chairimenti credo di non riuscire ad andare avanti nell'apprendimento...
Anche secondo me, se prima non colmi le lacune sui concetti e la sintassi di base, non puoi procedere con l'apprendimento. Secondo me, però, per te sarebbe più proficuo colmare queste lacune in modo organico, non a colpi di domande che sorgono in seguito a risposte che ottieni ad altre domande.
Cioè, puoi fare anche così, però a mio avviso ci metti (molto) più tempo e fai più fatica.

Un modo organico per colmare queste lacune sarebbe quello di studire un testo di riferimento specifico (un qualsiasi manuale/tutorial sul linguaggio Java copre sicuramente questi argomenti, che sono proprio le basi minime).

Se non hai niente del genere sottomano e mastichi l'inglese anche solo a livello scolastico, fatti i tutorial (comprese le domande/esercizi alla fine di ogni blocco/capitolo) "Getting Started" e "Learning the Java Language" che trovi qui:
http://docs.oracle.com/javase/tutorial/tutorialLearningPaths.html#buildingon

[Vincent79]

Non riesco a capire il tuo esempio:
1 - se Anno è, nelle tue intenzioni, una classe, quel pseudocodice Java cosa fa? Dichiara la classe e al contempo il costruttore? Quindi, in quel contesto, 'età' è un campo della classe?
2 - Il metodo getAnno cosa dovrebbe fare? Non riesco a capirlo. Inoltre, newEtà da dove salta fuori?


Anche secondo me, se prima non colmi le lacune sui concetti e la sintassi di base, non puoi procedere con l'apprendimento. Secondo me, però, per te sarebbe più proficuo colmare queste lacune in modo organico, non a colpi di domande che sorgono in seguito a risposte che ottieni ad altre domande.
Cioè, puoi fare anche così, però a mio avviso ci metti (molto) più tempo e fai più fatica.

Un modo organico per colmare queste lacune sarebbe quello di studire un testo di riferimento specifico (un qualsiasi manuale/tutorial sul linguaggio Java copre sicuramente questi argomenti, che sono proprio le basi minime).

Se non hai niente del genere sottomano e mastichi l'inglese anche solo a livello scolastico, fatti i tutorial (comprese le domande/esercizi alla fine di ogni blocco/capitolo) "Getting Started" e "Learning the Java Language" che trovi qui:
http://docs.oracle.com/javase/tutorial/tutorialLearningPaths.html#buildingon

Nell'esempio che io ho fatto, ho trasciato qualche dichiarazione (tipo newEtà) era giusto un esempio per capire meglio l'utilizzo del this...

come testi, ne ho già tanti e in più ho preso anche Mattone per Mattone...
Gran parte dei concetti li ho già studiati, solo che stavo cecando di approfondire i punti che non riesco a capire, perchè mi sono reso conto che spesso non riesco a decifrare la tracce degli esercizi...
Cmq grazie per le risposte intanto do uno sguardo anche al testo che mi hai consigliato

[Vincent79]

Ho fatto una bella studiata a diversi concetti del manuale che mi ha consigliato, molte cose cose sono più chiare, anche se ho dovuto tradurre tutto...
per volevo postarti qualche concetto che non è del tutto chiaro...
due parole in inglese delle quali non riesco a trovare la giusta traduzione:
1)namespace, incontrata nella sezione Package
2)shadow, incontrata nel nome dei parametri
e poi questa sezione che non è per niente chiara...

Passing Reference Data Type Arguments

In questa sezione di codice, abbiamo un nuovo oggetto circle al quale modifichiamo le coordinate di origine.
Quello che non riesco a capire è l'assegnazione circle = new Circle(0, 0);
questa dichiarazione non azzera le coordinate, quando invochiamo il metodo?
se no perchè?

public void moveCircle(Circle circle, int deltaX, int deltaY) {
// code to move origin of
// circle to x+deltaX, y+deltaY
circle.setX(circle.getX() + deltaX);
circle.setY(circle.getY() + deltaY);

// code to assign a new
// reference to circle
circle = new Circle(0, 0);
}

Poi invocando il metodo nel seguente modo,

moveCircle(myCircle, 23, 56)

abbiamo le nuove coordinate...

[banryu79]

per volevo postarti qualche concetto che non è del tutto chiaro...
due parole in inglese delle quali non riesco a trovare la giusta traduzione:
1)namespace, incontrata nella sezione Package
2)shadow, incontrata nel nome dei parametri

1) puoi tradurre "namespace" con "spazio dei nomi".
Un package crea uno spazio dei nomi, cioè uno spazio virtuale dove puoi nominare delle entità (membri del package: interfaccie, classi, enumerazioni, ecc...).
Una entità è poi univocamente determinata dal suo nome pienamente qualificato (fully qualified name) che comprende il nome del package in cui si trova.
Il fatto che un package crei uno spazio dei nomi permette di creare entità omonime purchè in package diversi (cioè in spazi dei nomi diversi).
Ad esempio, nelle librerie standard ci sono almeno due classi che si chiamano "Date", una in java.sql e l'altra in java.util: questi sono due diversi package, e creano due diversi spazi dei nomi.

2) "shadow" letteralmente si traduce con "ombra". Però non ho capito dove hai trovato questo termine i relazione ai "nomi dei parametri", puoi postare un link alla pagina o riportare un estratto del testo?



e poi questa sezione che non è per niente chiara...

Passing Reference Data Type Arguments

Reference data type parameters, such as objects, are also passed into methods by value. This means that when the method returns, the passed-in reference still references the same object as before. However, the values of the object's fields can be changed in the method, if they have the proper access level.

For example, consider a method in an arbitrary class that moves Circle objects:

public void moveCircle(Circle circle, int deltaX, int deltaY) {
// code to move origin of
// circle to x+deltaX, y+deltaY
circle.setX(circle.getX() + deltaX);
circle.setY(circle.getY() + deltaY);

// code to assign a new
// reference to circle
circle = new Circle(0, 0);
}
Let the method be invoked with these arguments:

moveCircle(myCircle, 23, 56)
Inside the method, circle initially refers to myCircle. The method changes the x and y coordinates of the object that circle references (i.e., myCircle) by 23 and 56, respectively. These changes will persist when the method returns. Then circle is assigned a reference to a new Circle object with x = y = 0. This reassignment has no permanence, however, because the reference was passed in by value and cannot change. Within the method, the object pointed to by circle has changed, but, when the method returns, myCircle still references the same Circle object as before the method was called.
Questo estratto fa parte della pagina che parla del passaggio degli argomenti ai metodi.
In sintesi dice che in Java il passaggio delle variabili (tipi primitivi e reference) come argomenti ai metodi è sempre per valore (by value).

Quando passi come argomento una reference ad un metodo, il metodo crea una sua copia locale della reference: in questo modo la reference passata come argomento non potrà essere modificata dal metodo e continuerà a puntare sempre allo stesso oggetto. Allo stesso tempo, il metodo può usare la sua copia locale della reference passata per accedere all'oggetto puntato da quella reference.

[Vincent79]

1) puoi tradurre "namespace" con "spazio dei nomi".
Un package crea uno spazio dei nomi, cioè uno spazio virtuale dove puoi nominare delle entità (membri del package: interfaccie, classi, enumerazioni, ecc...).
Una entità è poi univocamente determinata dal suo nome pienamente qualificato (fully qualified name) che comprende il nome del package in cui si trova.
Il fatto che un package crei uno spazio dei nomi permette di creare entità omonime purchè in package diversi (cioè in spazi dei nomi diversi).
Ad esempio, nelle librerie standard ci sono almeno due classi che si chiamano "Date", una in java.sql e l'altra in java.util: questi sono due diversi package, e creano due diversi spazi dei nomi.

Ok perfetto, quindi le librerie contengono i package, cioè le prime sono più grandi!!!

2) "shadow" letteralmente si traduce con "ombra". Però non ho capito dove hai trovato questo termine i relazione ai "nomi dei parametri", puoi postare un link alla pagina o riportare un estratto del testo?
ti posto le righe dove c'è la parola shadow:

A parameter can have the same name as one of the class's fields. If this is the case, the parameter is said to shadow the field. Shadowing fields can make your code difficult to read and is conventionally used only within constructors and methods that set a particular field.

cioè qui dice che nel caso ci fossero due variabili con due nomi uguali, però una appartenente alla variabile di classe e l'altro è un semplice parametro, quest'ultimo si dice che oscura la variabile di classe....
se ho capito bene!!!


Questo estratto fa parte della pagina che parla del passaggio degli argomenti ai metodi.
In sintesi dice che in Java il passaggio delle variabili (tipi primitivi e reference) come argomenti ai metodi è sempre per valore (by value).

Quando passi come argomento una reference ad un metodo, il metodo crea una sua copia locale della reference: in questo modo la reference passata come argomento non potrà essere modificata dal metodo e continuerà a puntare sempre allo stesso oggetto. Allo stesso tempo, il metodo può usare la sua copia locale della reference passata per accedere all'oggetto puntato da quella reference.

faccio un esempio per mostrarti se ho capito:

int x = 5;
public void addValue() {
...
}

addValue.x;

non badare a cosa dovrebbe fare il metodo...manca tutto...è giusto un prototipo per vedere se ho capito il concetto...
quindi il metodo addValue utilizza la varibile int che vale 5;

A tutto questo ci aggiungo una nuova domanda riguardante l'utilizzo degli oggetti;

int height = new Rectangle().height;

questo codice crea un nuovo oggetto Rectangle assegnando un valore ad height. Dopo questa esecuzione, non abbiamo una referenza al Rectangle creato, perchè il programma non la memorizza da nessuna parte...
quindi diciamo che è una inizializzazione fasulla...!!!???

[banryu79]

1) puoi tradurre "namespace" con "spazio dei nomi".
Un package crea uno spazio dei nomi, cioè uno spazio virtuale dove puoi nominare delle entità (membri del package: interfaccie, classi, enumerazioni, ecc...).
Una entità è poi univocamente determinata dal suo nome pienamente qualificato (fully qualified name) che comprende il nome del package in cui si trova.
Il fatto che un package crei uno spazio dei nomi permette di creare entità omonime purchè in package diversi (cioè in spazi dei nomi diversi).
Ad esempio, nelle librerie standard ci sono almeno due classi che si chiamano "Date", una in java.sql e l'altra in java.util: questi sono due diversi package, e creano due diversi spazi dei nomi.
Ok perfetto, quindi le librerie contengono i package, cioè le prime sono più grandi!!!

No, le librerie non *contengono* (in senso stretto) i package; al massimo potremmo dire che con il termine "libreria" (nel contesto di Java) si intende un insieme di classi organizzate in uno o più package correlati (e, a volte, anche altre risorse), che implementano una (o più) funzionalità. In linea di massima, questo insieme di classi è definito da un insieme di file .java che vengono compilati e formano un insieme di file .class il quale, a sua volta, viene infilato in uno (o più) file .jar (insieme alle eventuali altre risorse).
Il file .jar finale contiene tutto l'ambaradam e forma la "libreria".
Ma i package, concettualmente, non sono *contenuti* da alcunchè.

Quando si parla di librerie standard, nel contesto di Java, si fa riferimento a quell'insieme di classi e risorse organizzate in package distribuito con il JDK.

[banryu79]

2) "shadow" letteralmente si traduce con "ombra". Però non ho capito dove hai trovato questo termine i relazione ai "nomi dei parametri", puoi postare un link alla pagina o riportare un estratto del testo?
ti posto le righe dove c'è la parola shadow:

A parameter can have the same name as one of the class's fields. If this is the case, the parameter is said to shadow the field. Shadowing fields can make your code difficult to read and is conventionally used only within constructors and methods that set a particular field.

cioè qui dice che nel caso ci fossero due variabili con due nomi uguali, però una appartenente alla variabile di classe e l'altro è un semplice parametro, quest'ultimo si dice che oscura la variabile di classe....
se ho capito bene!!!

Sì. Un esempio è quello di una ipotetica classe Persona che definisce un campo di nome "nome" e un metodo setNome che accetta un parametro anch'esso di nome "nome":

class Persona {
String nome; //campo della classe

void setNome(String nome) { // parametro del metodo
...
}
}

Nello scope del metodo setNome, il parametro "nome" oscura (o nasconde, se preferisci) il campo di classe "nome" (anch'esso visibile nello scope del metodo).
Quindi, nello scope del metodo setNome, dire "nome" identifica il parametro e non il campo.
Per indicare il campo si usa la keyword this:

class Persona {
String nome; //campo della classe

void setNome(String nome) { // parametro del metodo
this.nome = nome;
}
}


Oppure puoi evitare a monte il fenomeno dell'oscuramento dando un nome diverso al parametro, ad esempio:

class Persona {
String nome; //campo della classe

void setNome(String newNome) { // parametro del metodo
nome = newNome;
}
}

[banryu79]

faccio un esempio per mostrarti se ho capito:

int x = 5;
public void addValue() {
...
}

addValue.x;

non badare a cosa dovrebbe fare il metodo...manca tutto...è giusto un prototipo per vedere se ho capito il concetto...
quindi il metodo addValue utilizza la varibile int che vale 5;

Il tuo esempio non mi è chiaro per niente: cosa dovrebbe significare quell'addValue.x alla fine? Perchè quello sembrerebbe un accesso al campo 'x' su addValue, ma addValue è un metodo e i metodi non hanno campi. Quell'istruzione non è valida in Java.

Tra l'altro: 'x' e 'addValue' dove si trovano? Sono parte della definizione di una classe, presumo...


A tutto questo ci aggiungo una nuova domanda riguardante l'utilizzo degli oggetti;

int height = new Rectangle().height;

questo codice crea un nuovo oggetto Rectangle assegnando un valore ad height. Dopo questa esecuzione, non abbiamo una referenza al Rectangle creato, perchè il programma non la memorizza da nessuna parte...
quindi diciamo che è una inizializzazione fasulla...!!!???

Sì, l'istruzione new Rectangle() crea una istanza di Rectangle e l'operatore '.' accede al membro 'height' di quell'istanza: presumento che 'height' sia di tipo int (oppure di tipo java.lang.Integer, per via del meccanismo dell'autoboxing) il valore di quel membro viene assegnato alla variabile 'height' di tipo int.
Comunque l'assegnamento alla variabile intera 'height' è e resta valido a prescindere dal fatto che l'stanza appena creata di Rectangle non viene assegnata ad un riferimento.

[Vincent79]

Il tuo esempio non mi è chiaro per niente: cosa dovrebbe significare quell'addValue.x alla fine? Perchè quello sembrerebbe un accesso al campo 'x' su addValue, ma addValue è un metodo e i metodi non hanno campi. Quell'istruzione non è valida in Java.

Tra l'altro: 'x' e 'addValue' dove si trovano? Sono parte della definizione di una classe, presumo...

Diciamo che sia x che addValue() sono parte di una classe!
Ti ripeto non badare a cosa dovrebbero fare perchè è giusto per capire come ragiona il codice...

credo di aver sbagliato io a comporre il codice;

addValue().x;

allora, il valore di x, che è un int, dovrebbe essere passato al metodo addValue(), giusto?

PS: per il resto è tutto chiaro, finalmente ho capito anche il this...:D :D :D

[Vincent79]

Giusto una conferma per quanto riguarda il this.

The most common reason for using the this keyword is because a field is shadowed by a method or constructor parameter.

it could have been written like this:

public class Point {
public int x = 0;
public int y = 0;

//constructor
public Point(int x, int y) {
this.x = x;
this.y = y;
}
}
Each argument to the constructor shadows one of the object's fields — inside the constructor x is a local copy of the constructor's first argument. To refer to the Point field x, the constructor must use this.x.

in questo caso, this.x e this.y si riferiscono alla variabile di istanza, e non ai parametri del costruttore, giusto???

[banryu79]

Diciamo che sia x che addValue() sono parte di una classe!
Ti ripeto non badare a cosa dovrebbero fare perchè è giusto per capire come ragiona il codice...

Ma io infatti "non bado a cosa dovrebbero fare", perchè anche io quando ti scrivo dello pseudo-codice di esempio non definisco il corpo dei metodi se non è strettamente neccessario; però cerco sempre di scrivere codice Java sintatticamente corretto, tu invece in quell'esempio hai proprio scritto roba non corretta, il che ci riporta a...


credo di aver sbagliato io a comporre il codice;

addValue().x;

allora, il valore di x, che è un int, dovrebbe essere passato al metodo addValue(), giusto?

Anche addValue().x non va bene.

Hai detto che addValue è un metodo e x è una variabile di tipo int.
Se parli di passare x, che è un int, al metodo addValue allora bisogna correggere il tuo esempio così:

// definizione di addValue
void addValue(int val) {
...
}

Da qualche altra parte:

// chiamo addValue passando 'x' come argomento
int x = 10;
addValue(x);



Giusto una conferma per quanto riguarda il this.
...
in questo caso, this.x e this.y si riferiscono alla variabile di istanza, e non ai parametri del costruttore, giusto???

Sì, giusto.

[Vincent79]

Allora esaminiamo questi due codici:

int height = new Rectangle().height;

addValue().x

il primo è sintatticamente corretto, invece il secondo no perchè non posso passare un int ad un metodo in questo modo...
invece posso farlo per la creazione di un nuovo oggetto al quale passo height
in fase di esecuzione effettivamente cosa cacchio fanno...

[banryu79]

Allora esaminiamo questi due codici:

int height = new Rectangle().height;

addValue().x

il primo è sintatticamente corretto, invece il secondo no perchè non posso passare un int ad un metodo in questo modo...
invece posso farlo per la creazione di un nuovo oggetto al quale passo height
in fase di esecuzione effettivamente cosa cacchio fanno...
Umm... direi che stai facendo confusione.
Partiamo esaminando in dettaglio i due pseudo codici che hai scritto:

int height = new Rectangle().height;

Qui si sta definendo una variabile di tipo int con il nome 'height' (verde) E le si sta assegnando un valore (sienna).
Ma che valore? Questo:

new Rectangle().height;

Qui si sta (verde) creando una istanza della classe Rectangle (che ovviamente sarà definita da qualche parte) e (blue) accedendo al campo di nome 'height' di questa istanza di Rectangle appena creata (anche qui vale l'osservazione di prima, cioè da qualche parte deve esistere la definizione di Rectangle che tra l'altro stabilisce che Rectangle ha un campo di nome 'height' e di tipo int).

Chiarito questo, uno potrebbe notare che è quanto meno curioso il fatto che si crei un'istanza di un Rectangle solo per accedere al suo campo 'height' per usarne il valore al fine di inizializzare una variabile. Ma tant'è, l'esempio l'hai scritto tu; il fatto è che questo è codice Java valido, sintatticamente, a patto che da qualche parte esista anche una definizione del tipo:

public class Rectangle {
public int height;
}


Esaminiamo ora:

addValue().x;

Qui abbiamo due istruzioni, una chiamata di un metodo (sienna) e un accesso ad un campo di nome 'x' tramite il dot operator '.' (blue).

Attenzione che quindi qui non c'è nessun passaggio di 'x' come parametro al metodo addValue. Se volevi fare un'esempio di passaggio di un parametro ad un metodo (e da quello che hai scritto mi pare di capire che questa fosse la tua intenzione) allora la sintassi corretta sarebbe stata questa:

addValue(x);

Chiamata del metodo 'addValue' (oliva) con passaggio di 'x' come argomento (mattone).

A dire il vero questo potrebbe essere sintatticamente valido:

addValue().x;

nel caso in cui il metodo 'addValue' restituisca l'istanza di una qualsiasi classe la cui definizione contenga un campo 'x'.
Tipo:

MyObject addValue() {
return new MyObject();
}

class MyObject {
public int x;
}

[Vincent79]

ahhhhhhhhhh!!!
Perfetto, ora è un pò pi chiaro...
il punto è ora cercare di fissare questi concetti tramite esercizi...
sapresti indicarmi un sito che ha una lista ddi esercizi guida, possibilmente con soluzioni, giusto per avere un confronto...
altrimenti li posto a te :D :D :D

ora devo cimentarmi con un esercizio che sta sul sito di oracle

Write a class whose instances represent a single playing card from a deck of cards. Playing cards have two distinguishing properties: rank and suit. Be sure to keep your solution as you will be asked to rewrite it in Enum Types.

quindi ragioniamo, devo creare due metodi, uno rank e suit, che devono darmi rispettivamente colore e valore...
fin qui non ci piove...ora però come devo ragionare...per andare avanti!!!
il programma deve semplicemente visualizzare a video il valore di una carta...

[banryu79]

Perdonami Vincent79, non voglio assolutamente essere polemico, ma solo aiutarti per come posso. Secondo me, se ancora hai le difficoltà che hai mostrato negli utlimi post (non ti sono chiari gli elementi sintattici di base del linguaggio) non è producente affrontare esercizi del tipo che hai descritto (che sono focalizzati su aspetti leggermente successivi alla corretta acquisizione della sintassi base).

Io ti consiglio di studiare/ripassare bene le basi del linguaggio su un apposito testo e fare i tre tutorial sotto al titolo "New To Java" che trovi a questa pagina (http://docs.oracle.com/javase/tutorial/tutorialLearningPaths.html#buildingon); ci sono degli esercizi (domande) con le relative soluzioni.

[Vincent79]

Perdonami Vincent79, non voglio assolutamente essere polemico, ma solo aiutarti per come posso. Secondo me, se ancora hai le difficoltà che hai mostrato negli utlimi post (non ti sono chiari gli elementi sintattici di base del linguaggio) non è producente affrontare esercizi del tipo che hai descritto (che sono focalizzati su aspetti leggermente successivi alla corretta acquisizione della sintassi base).

Io ti consiglio di studiare/ripassare bene le basi del linguaggio su un apposito testo e fare i tre tutorial sotto al titolo "New To Java" che trovi a questa pagina (http://docs.oracle.com/javase/tutorial/tutorialLearningPaths.html#buildingon); ci sono degli esercizi (domande) con le relative soluzioni.

Nessuna polemica, anzi farò esattamente come tu mi stai dicendo...
ora mi ripasso il tutto, poi do una spulciata al link che mi hai postato e ci sentiamo appena le termino questo lavoro...
Ti ringrazio tantissimo per la tua disponibilità e pazienza...
fammi sapere quando vai in vacanza che così non ti rompo...
ciao!!!

[banryu79]

Ti ringrazio tantissimo per la tua disponibilità e pazienza...
fammi sapere quando vai in vacanza che così non ti rompo...
ciao!!!
Di niente, se ho tempo rispondo.
Comunque sono in ferie dal 13 al 27 agosto, e non mi collegherò mai in internet (ferie completamente offline).
Ci sentiamo quando ci sentiamo :D

Comunque, per quell'esercizio delle carte, per quando ci arriverai e l'avrai fatto da solo (e non prima, sarebbe meglio per te) puoi provare a confrontare le tue soluzioni e quelle proposte da dove hai preso l'esercizio (se ce ne sono) con gli spunti che trovi in questo thread:
http://www.hwupgrade.it/forum/showthread.php?t=2458837

[Vincent79]

eccomi sono tornato...
dopo una pausa sabatica...
preparati a risolvere altri miei sicuri dubbi...
ciao...

[Vincent79]

stavo riprendendo un pò la mano con la programmazione...
allora ho sviluppato un esercizio dove calcolare l'area di un rettangolo.
Successivamente, devo prendere le due aree, confrontarle e determinare la più grande.
ebbene nell'interfaccia della classe ho creato questo metodo:

public void getArea() {
double area;
area = base * altezza;
System.out.print(area);
}

questo metodo è void per cui non restoriusice nulla (se non il valore dell'area);
per il confronto ho bisogno del ciclo if, ma come faccio a determinare i termini di paragone, dato che mi servono i valori delle due aree???

Ps: non voglio cambiare il metodo dichiarandolo double e con la conseguente restituzione di un dato!!!

[banryu79]

stavo riprendendo un pò la mano con la programmazione...
allora ho sviluppato un esercizio dove calcolare l'area di un rettangolo.

Premessa: quando parliamo di esercizi, se posti il testo dell'esercizio è meglio, così possiamo fare riferimento alle richieste da soddisfare senza doverle presumere, potendo così evitare perdite di tempo e fraintendimenti.
Questo ammesso che l'esercizio in questione ti sia stato dato,
e non sia invece stato tu a inventarlo.

Partendo dalle sole informazioni presenti nel tuo post, provo a estrarre le parti rilevanti al fine di determinare il problema e i suoi requisiti:

...allora ho sviluppato un esercizio dove calcolare l'area di un rettangolo.
Successivamente, devo prendere le due aree, confrontarle e determinare la più grande.

Allora io qua vedo due "entità": Area e Rettangolo.
Deduco anche che:
1) Area è calcolabile da Rettangolo.
2) un Area è confrontabile con un'altra Area.

Non ho altre informazioni, percui il resto lo presumo arbitrariamente.

Ad esempio presumo il fatto che un Rettangolo è costituito dalle due misure dei suoi lati (quello maggiore e quello minore). Presumo il fatto che le misure di questi lati siano espresse in termini di valori interi positivi, a pensarci bene interi positivi strettamente maggiori di 0.

In questo modo rappresento l'entità Rettangolo così:

class Rectangle {
final int sideA, sideB;

public Rectangle(int sideA, int sideB) {
if (sideA< 1 || sideB< 1) {
throw new IllegalArgumentException("Zero or negative side value");
}
this.sideA= sideA;
this.sideB= sideB;
}
}

Poi devo rappresentare il fatto che di un Rettangolo posso calcolarne l'Area.
Rappresento questo fatto con un metodo "getArea", così:

class Rectangle {
final int sideA, sideB;

public Rectangle(int sideA, int sideB) {
if (sideA< 1 || sideB< 1) {
throw new IllegalArgumentException("Invalid side value");
}
this.sideA = sideA;
this.sideB = sideB;
}

public Area getArea() {
return new Area(sideA * sideB);
}
}

Ho anche stabilito che una entità Area è costituita da un valore intero. A dire il vero quest'ultimo passaggio andrebbe esaminato meglio, perchè ad esempio potrei avere il caso di un Rettangolo i cui lati hanno valori int molto grandi che, se moltiplicati tra loro, potrebbero produrre un valore intero troppo grande per poter essere rappresentato dal tipo primitivo int ma... per questioni di semplicità per ora assumiamo di rappresentare anche Area con un valore intero (int).

A questo punto ho:

class Area {
final int value;

public Area(int value) {
this.value = value;
}
}

Per come è definita, un'Area può anche avere valore negativo.
Per ciò che si intende per Area non ha molto senso, d'altro canto concettualmente può essere interessante avere Aree negative; in ultima analisi dipende dai requisisti del problema e da considerazioni di opportunità.

Manca il confronto tra due Aree:

class Area {
final int value;

public Area(int value) {
this.value = value;
}

public int compareTo(Area other) {
return this.value - other.value;
}
}

La logica del metodo compareTo è di restituire al chiamante un valore negativo se la nostra Area (this) è più piccola di quell'altra (other), viceversa un valore positivo e zero se le due Aree sono equivalenti.

Ora che abbiamo definito le nostre due entità (Rettangolo, Area) nei termini del problema ("...calcolare l'area di un rettangolo...", "...confrontarle...") possiamo mettere insieme i pezzi e "montare" la soluzione.

Esempio:

public class CalcoloRettangoliEAree {
public static void main(String... args) {
Rectangle retA = new Rectangle (12,4);
Rectangle retB = new Rectangle (3,16);
evaluate(retA, retB);
}

static void evaluate(Rectangle r1, Rectangle r2) {
int result = r1.getArea().compareTo(r2.getArea());
if (result > 0) {
println(l'area di r1 è maggiore dell'area di r2);
}
else if (result < 0) {
println(l'area di r1 è minore dell'area di r2);
}
else {
println(l'area di r1 è uguale all'area di r2);
}
}

static void println(String message) {
System.out.println(message);
}
}

[Vincent79]

io avevo fatto in questo modo

public class AreaRettangolo {
public AreaRettangolo(double newAltezza, double newBase) {
altezza = newAltezza;
base = newBase;
}

public void getArea() {
double area;
area = base * altezza;
System.out.print(area);
}

private double altezza;
private double base;

}


e poi nel test

import java.io.*;
public class AreaTest {
public static void main(String[] arg) throws Exception {

BufferedReader br;
String line1, line2;
double altezza, base;

System.out.println("Calcoliamo l'area di due rettangoli!");
System.out.println("RETTANGOLO 1");
AreaRettangolo a1, a2;
br = new BufferedReader(new InputStreamReader(System.in));
System.out.print("Scrivi l'altezza: ");
line1 = br.readLine();
System.out.print("Scrivi la base: ");
line2 = br.readLine();
altezza = Integer.parseInt(line1);
base = Integer.parseInt(line2);
System.out.print("Il calcolo della prima area è: ");
a1 = new AreaRettangolo(altezza, base);
a1.getArea();

System.out.println();

System.out.println("RETTANGOLO 2");
System.out.print("Scrivi l'altezza: ");
line1 = br.readLine();
System.out.print("Scrivi la base: ");
line2 = br.readLine();
altezza = Integer.parseInt(line1);
base = Integer.parseInt(line2);
System.out.print("Il calcolo della seconda area è: ");
a2 = new AreaRettangolo(altezza, base);
a2.getArea();

}

}

a questo punto avevo pensato di inserire un ciclo if per il confronto!!!
PS: l'esercizio l'ho abbozzato io...

[banryu79]

Riporto il codice che hai postato nel tag CODE (per l'identazione):

public class AreaRettangolo {
public AreaRettangolo(double newAltezza, double newBase) {
altezza = newAltezza;
base = newBase;
}

public void getArea() {
double area;
area = base * altezza;
System.out.print(area);
}

private double altezza;
private double base;
}


import java.io.*;
public class AreaTest {
public static void main(String[] arg) throws Exception {
BufferedReader br;
String line1, line2;
double altezza, base;

System.out.println("Calcoliamo l'area di due rettangoli!");
System.out.println("RETTANGOLO 1");
AreaRettangolo a1, a2;
br = new BufferedReader(new InputStreamReader(System.in));
System.out.print("Scrivi l'altezza: ");
line1 = br.readLine();
System.out.print("Scrivi la base: ");
line2 = br.readLine();
altezza = Integer.parseInt(line1);
base = Integer.parseInt(line2);
System.out.print("Il calcolo della prima area è: ");
a1 = new AreaRettangolo(altezza, base);
a1.getArea();

System.out.println();

System.out.println("RETTANGOLO 2");
System.out.print("Scrivi l'altezza: ");
line1 = br.readLine();
System.out.print("Scrivi la base: ");
line2 = br.readLine();
altezza = Integer.parseInt(line1);
base = Integer.parseInt(line2);
System.out.print("Il calcolo della seconda area è: ");
a2 = new AreaRettangolo(altezza, base);
a2.getArea();
}

}


A questo punto:

a questo punto avevo pensato di inserire un ciclo if per il confronto!!!

Gli statement for, while e do-while sono looping statements (cicli).
Lo statement if (appartenente al gruppo if-then, if-then-else, switch) non è un ciclo ;)

Detto questo, hai difficoltà a immaginare come utilizzare lo statement if nel metodo main per fare il confronto tra le due aree per il semplice motivo che non hai a disposizione i due valori delle aree da confrontare, poichè hai scelto di implementare il metodo getArea della classe AreaRettangolo in modo che non restiuisca nulla al chiamante (e quindi, tra l'altro, il nome del metodo, getArea è fourviante perchè esiste una convenzione ben radicata circa il fatto che quando al nome di un metodo è prefissa la particella get, quel metodo restiuisce qualcosa al chiamante).
Visto quello che fa il metodo getArea da te implementato, forse era più appropriato chiamarlo printArea.


Comunque la soluzione più ovvia, in questo caso, è:
Implementare getArea in modo che restituisca proprio il valore dell'area calcolato.
A quel punto, nel main, puoi "mettere le mani" sul valore delle aree confrontarle e in base al risultato del confronto diramare il flusso di esecuzione del programma (if-then-else).


Dopo che hai realizzato questa modifica, col codice che così verrai a trovarti potresti fare quest'altro esercizio che ti do io:
Il codice che implementa il metodo main contiene delle ridondanze inutili. Prova a identificare queste ridondanze, e a fattorizzarle (identifica il codice che si ripete, analizzalo e isola le parti costanti e quelle variabili, quindi crea un metodo che esegua la parti costanti della ridondanza passandogli come parametri le parti variabili. A questo punto, nel main, puoi sostituire le parti ridondanti con chiamate al nuovo metodo.

[Vincent79]

Salve gente, ho da poco ripreso la programmazione...
fino a qualche giorno fa tutto funzionava bene, poi ho creato una classe "Quattro" e quando ho cercato di creare un file su disco gestendone i dati, mi è uscito questo simpatico errore...girando un pò sul web ho visto che potevo cambiare estensione del file creato, ma nulla!!!
Come posso risolvere il problema???

Vi posto il mess. di errore
Exception in thread "main" java.io.FileNotFoundException: nameFile (Impossibile trovare il percorso specificato)
at java.io.FileInputStream.open(Native Method)
at java.io.FileInputStream.<init>(Unknown Source)
at Quattroo.main(Quattroo.java:5)

[ingframin]

Salve gente, ho da poco ripreso la programmazione...
fino a qualche giorno fa tutto funzionava bene, poi ho creato una classe "Quattro" e quando ho cercato di creare un file su disco gestendone i dati, mi è uscito questo simpatico errore...girando un pò sul web ho visto che potevo cambiare estensione del file creato, ma nulla!!!
Come posso risolvere il problema???

Vi posto il mess. di errore
Exception in thread "main" java.io.FileNotFoundException: nameFile (Impossibile trovare il percorso specificato)
at java.io.FileInputStream.open(Native Method)
at java.io.FileInputStream.<init>(Unknown Source)
at Quattroo.main(Quattroo.java:5)

1) Il file esiste?
2) Se il file non esiste hai impostato la open col permesso di scrivere?
3) Hai il permesso di leggere e scrivere su quell'unità?

[Vincent79]

1) Il file esiste?
2) Se il file non esiste hai impostato la open col permesso di scrivere?
3) Hai il permesso di leggere e scrivere su quell'unità?

1)il file non esiste, devo crearlo io, ma la cosa strana è che prima me lo creava senza problemi...con un'estensione strana ma me lo creava...
2)se nel programma inserisco un file esistente, funziona tutto, ma ripeto il mio compito è quello di crearlo...
3)come faccio a modificare il permesso per write & read sull'unità?

Grazie!!!

[Vincent79]

Sembra che ho risolto, praticamente impostando le librerie nel percorso di Eclipse, project - proprietà - JavaBuildPath...
Comunque resta un mistero e non so per quale motivo mi abbia fatto questo scherzetto;
grazie lo stesso per la risposta!!!

[Vincent79]

Archiviate le vacanze....si riprende
mi trovo alle prese con questo eser.
Vi posto la traccia:

Scrivere una classe Pubblicazione i cui oggetti rappresentano pubblicazioni.
Queste sono le variabili di istanza: Titolo e Autore (tipo String), Numero di Pagine e Prezzo Copertina (di tipo int).

La classe deve avere i seguenti metodi:
costruttore - prende come parametri titolo, autore e prezzo di cop. inizializzandoli (supporre che ogni pagina costi 0.10 €).
metodi - getTitolo, getAutore, getPrezzo e getPagine che restituiscono i valori degli attributi
metodi - setTitolo, setAutore, setPrezzo e setPagine che modificano i valori degli attr. (NB: se modifico il prezzo, allora anche il numero di pagine deve essere modificato di conseguenza, e viceversa).
metodo toString - infine tale metodo deve restituire una stringa con i dati dell'oggetto su cui è invocato.

Ebbene, io ho già fatto una bozza del programma, soltanto che non riesco a capire come svolgere l'ultimo punto (quello in blu per intenderci)...
creo il metodo toString e poi...!!!!???

[gokan]

Ciao il metodo toString() lo devi usare per restituire una forma leggibile dell'oggetto su cui è invocato.
Alcuni IDE di sviluppo te lo costruiscono in automatico.
Un esempio sarebbe questo:

public String toString(){
return "Pubblicazione{Titolo:"+this.titolo+",Autore:"+this.autore+",..."+"}";
}


Bye