Semplice programmino in Java

[djadry]

Ciao a tutti. Sono alle primissime armi con Java; voglio scrivere un programmino che quando inserisco una stringa mi restituisca un valore int contenente il numero dei caratteri da cui è composta la suddetta stringa.

Quello che ho fatto fino ad ora è:

//Contatore di parole

import prog.io.*;
import prog.utili.*;

class ContatoreParole {
public static void main(String[] args) {

//predisposizione canali di comunicazione
ConsoleInputManager tastiera = new ConsoleInputManager();
ConsoleOutputManager monitor = new ConsoleOutputManager();

//lettura stringa
String messaggio = tastiera.readLine();
int x = messaggio.lenght();

//comunicazione dati
monitor.println(x);

}
}


da qui in avanti però sono bloccato, non mi viene in mente cosa fare e non capisco se quello che ho fatto sia giusto:


//lettura stringa
String messaggio = tastiera.readLine();
int x = messaggio.lenght();

//comunicazione dati
monitor.println(x);

Badate che ConsoleInputManager è una classe creata dal mio docente, ha documentazione qui http://pighizzini.dico.unimi.it/jb/doc/prog/io/ConsoleInputManager.html

Grazie a chi mi risponderà!

[ndakota]

Hai lo stesso docente che ho avuto io due anni fa :D

Comunque riguardo al tuo problema non capisco, sembra corretto. Cosa non ti torna? Mi sembra tu abbia fatto tutto quello che ti eri prefissato di fare.

Edit: Se proprio vogliamo essere pignoli hai detto che vorresti restituire un intero ma l'hai stampato. Il che francamente mi sembra coerente per il tipo di esercizio.

[demos88]

//predisposizione canali di comunicazione
ConsoleInputManager tastiera = new ConsoleInputManager();
ConsoleOutputManager monitor = new ConsoleOutputManager();

Queste due istruzioni non fanno altro (suppongo) che creare due oggetti, uno di tipo ConsoleInputManager e uno di tipo ConsoleOutputManager. Il primo lo usi per le azioni di input, il secondo per l'output.

//lettura stringa
String messaggio = tastiera.readLine();
int x = messaggio.lenght();

La prima istruzione crea un oggetto di tipo String e lo istanzia con il valore ritornato dal metodo invocato sull'oggetto tastiera. Il metodo readLine non fa altro che leggere una stringa dalla console in cui fai girare il programmino.
La seconda istruzione crea una variabile intera x e le assegna la lunghezza della stringa letta. Infatti "messaggio" è un oggetto String e contiene la stringa letta da tastiera; il metodo "length()" (occhio al TH e non HT ;) ) ritorna la lunghezza della stringa contenuta nell'oggetto String sul quale è chiamato.

//comunicazione dati
monitor.println(x);
Questa istruzione manda in output la variabile x come stringa invocando il metodo println sull'oggetto monitor.

Purtroppo la sola documentazione non mi aiuta molto, diciamo che l'uso di quella classe personalizzata può risultare comodo in codici più lunghi ma qui, se fossi un professore, preferirei "mostrare di più e nascondere di meno".
Di fatto l'uso di quella classe ti nasconde il senso di quello che stai facendo.
Immaginando comunque il funzionamento di quel codice, te ne ripropongo un'altro che ho appena scritto, dovrebbe fare le stesse cose.

package prog;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class ContatoreParole {

/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
InputStreamReader strIn = new InputStreamReader(System.in);
BufferedReader in = new BufferedReader(strIn);

String messaggio = in.readLine();

int x = messaggio.length();

System.out.println(x);
}

}

Come vedi è banalissimo... lo stesso numero di righe di codice, con la differenza che la jvm non deve importare le classi personalizzate.
La tua classe ConsoleInputManager altro non è che una estensione funzionale dello stream in ingresso (System.in). Nel mio codice prima creo un oggetto strIn di tipo InputStreamReader indicandogli che voglio leggere dallo stream System.in , poi creo un oggetto di tipo BufferedReader che mi da la possibilità di leggere un buffer dallo stream indicato (perchè con strIn posso leggere solo un carattere per volta).
Fatto questo, il resto del programma come vedi è molto simile al tuo.

Spero sia chiaro :)

[djadry]

grazie mille per le risposte!

rispondendo a ndakota, il compilatore mi da un errore. come mi fa notare però demos88, ho scritto "lenght" al posto di "length".


rispondendo invece a demos88, purtroppo il codice che mi hai scritto non è molto chiaro (ho iniziato a scrivere programmi Java ieri :muro: ):

non conosco le classi che hai usato
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
e nemmeno questa dicitura
/**
* @param args
* @throws IOException
*/

ora comunque provo a correggere il "length" e a vedere se me lo compila :)
se va poi provo a riscrivere seguendo il codice che hai suggerito tu.

[djadry]

bene, perfetto. in definitiva avevo sbagliato proprio "lenght".

il codice finale è identico a quello nel primo post, con l'unica differenza del
//lettura stringa
String messaggio = tastiera.readLine();
int caratteri = messaggio.length();

//comunicazione dati
monitor.println(caratteri);

...certo che ho fatto un errore idiota :doh:

[demos88]

non conosco le classi che hai usato
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

Sono classi appartenenti alle librerie standard di java. Quelle classi le usa anche il tuo professore ma te lo "nasconde" dietro alle sue classi personalizzate.
Non è necessario conoscere a memoria cosa fa ogni classe delle librerie ufficiali (sono migliaia) ma quantomeno sapere che esistono.
Come ti ho riassunto sopra, BufferedReader è una classe che si occupa di gestire uno streaming come se fosse un buffer, ovvero di leggerlo a blocchi di lunghezza variabile (detto in modo molto semplice).
Mentre InputStreamReader è la classe che permette di leggere dallo stream che gli viene passato nel costruttore (nel ns caso System.in che è lo stream della tastiera).
Un oggetto InputStreamReader che legge da tastiera posso passarlo a un BufferedReader in modo da leggere blocchi di caratteri, nel nostro caso righe intere.
In realtà una delle peculiarità delle classi è la loro malleabilità, infatti se tu volessi leggere un file di testo anzichè da input tastiera, tu devi sempre creare un BufferedReader ma al posto di passargli un oggetto di tipo InputStreamReader, gliene passi uno di tipo FileReader (istanziato con uno stream a file).
Questo funziona con le librerie standard di java, probabilmente non con le classi che usi te.
Tuttavia capisco che se hai iniziato ieri, magari ti sto parlando in arabo, ma fra qualche settimana potrai capire tutto.
L'importante è metterci un po' di passione e voglia di capire, perchè quando capisci la logica di fondo, che in java può sembrare ostica ma in realtà non lo è, ti troverai molto meglio.

per completezza, la classe IOException è una delle classi eccezioni, ovvero degli oggetti che vengono creati e "sollevati" quando il codice incontra una inconsistenza (per esempio tentare di aprire un file che non esiste solleva una eccezione).


e nemmeno questoa dicitura
/**
* @param args
* @throws IOException
*/


Questa in realtà mi è sfuggita, sono dei commenti particolari chiamati javadoc.
Sono dei commenti che se aggiunti al codice nei punti giusti (per es prima di un metodo) permettono di generare il documento HTML che si chiama documentazione. Se tu vedessi il codice sorgente delle classi del tuo professore vedresti commenti di questo tipo per ogni metodo, commenti che contengono la descrizione che poi viene trascritta nella documentazione (quella che hai linkato) da un programmino che si chiama javadoc

[djadry]

ho capito tutto invece, grazie alla spiegazione mooolto esaudiente ;)

quindi di

/**
* @param args
* @throws IOException
*/non me ne frega niente. da quello che mi pare di capire dal libro di testo è equivalente ad un

// non so cosa scrivere, in quanto viene ignorato dal compilatore durante la fase di compilazione. l'unica differenza è che attraverso un programma chiamato javadoc genera questa documentazione di cui mi hai parlato. giusto?

[demos88]

/**
* @param args
* @throws IOException
*/non me ne frega niente. da quello che mi pare di capire dal libro di testo è equivalente ad un

// non so cosa scrivere, in quanto viene ignorato dal compilatore durante la fase di compilazione. l'unica differenza è che attraverso un programma chiamato javadoc genera questa documentazione di cui mi hai parlato. giusto?
Esatto, non viene considerato dal compilatore quindi che ci sia o non ci sia, il programma funziona in modo perfettamente identico.
Se lavori a progetti di dimensione non indifferente (sopra le 10mila righe) o se devi comunque fornire delle classi che altre persone devono usare, il javadoc è uno strumento essenziale di documentazione perchè è uno standard affermato (ed è lo stesso usato per documentare le classi delle librerie del java), altrimenti non è necessario, anche se usarlo nei progetti piccoli sarebbe buona abitudine. Se farai un corso di ingegneria del software, passerai ore a sentirti dire di documentare fino alla nausea :asd:

[djadry]

ok, ora mi è chiaro!

stamattina ha spiegato cose un pò più complesse, se avrò altri problemi continuerò in questa discussione :D

[djadry]

Riuppo questo topic per un altro problemino.

Ho creato un semplice programmino che dall'inserimento del nome e dell'anno di nascita ti dice quanti anni hai... Tuttavia mi è venuto in mente che tutti scriverebbero il loro nome in minuscolo, quindi mi piacerebbe trasformare la prima lettera del nome in maiuscolo.

il problema è che mi da un errore in compilazione. ho provato a sfogliare il libro ma non ho trovato nulla che mi aiutasse...

scusate la banalità, sto facendo tutto per "allenarmi". :D

ecco il codice:
import prog.io.*;

class CalcoloEta {
public static void main(String[] args)
{

//predisposizione canali comunuicazione
ConsoleInputManager tastiera = new ConsoleInputManager();
ConsoleOutputManager video = new ConsoleOutputManager();

//dichiarazione variabili utilizzate
int anno;
int eta;
String nome;
String inizNome;
String inizNomeToUp;
String restoNome;

//richiesta nome ed età
nome = tastiera.readLine("Inserisca il suo nome: ");
anno = tastiera.readInt("Inserisca il suo anno di nascita: ");

//calcolo età
eta = 2011 - anno;

//rendi maiuscola l'iniziale del nome
inizNome = nome.subsrting(0, 0);
inizNomeToUp = inizNome.toUpperCase();

//resto del nome
restoNome = nome.substring(1, 20);

//comunicazione risultato
video.println("Buongiorno " + inizNome + restoNome + ", hai " + eta + " anni.");

}
}

mi viene il dubbio che debba costruire un array. ditemi che sbaglio!

grazie in anticipo! :cool:

[djadry]

dopo un pò di scleri ho risolto così, grazie a tutti lo stesso :)

import prog.io.*;

class CalcoloEta {
public static void main(String[] args)
{

//predisposizione canali comunuicazione
ConsoleInputManager tastiera = new ConsoleInputManager();
ConsoleOutputManager video = new ConsoleOutputManager();

//dichiarazione variabili utilizzate
int anno;
int eta;
String nome;
String inizNome;
String inizNomeToUp;
String restoNome;

//richiesta nome ed età
nome = tastiera.readLine("Inserisca il suo nome: ");
anno = tastiera.readInt("Inserisca il suo anno di nascita: ");

//calcolo età
eta = 2011 - anno;

//rendi maiuscola l'iniziale del nome
inizNome = nome.substring(0, 1);
inizNomeToUp = inizNome.toUpperCase();

//ricava numero caratteri
int lunghezza = nome.length();

//resto del nome
restoNome = nome.substring(1, lunghezza);

//comunicazione risultato
video.println("Buongiorno " + inizNomeToUp + "" + restoNome + ", hai " + eta + " anni.");

}
}

[ndakota]

La mia soluzione :D


nome = Character.toUpperCase(nome.charAt(0)) + nome.substring(1);

[djadry]

La mia soluzione :D


nome = Character.toUpperCase(nome.charAt(0)) + nome.substring(1);


appena posso provo a sostiuire. certo che se questo metodo funziona, mi sono complicato parecchio la vita :Prrr:

[djadry]

scrivo sempre in questo topic :D

ragazzi come gestisco la creazione di alcune stringhe a seconda di un int che immette l'utente? più nello specifico devo creare delle stringhe che mi rappresentino delle frazioni.

sto provando a scrivere questo pezzo di codice, ma non so come continuare:
//quante frazioni?
int numF = tastiera.readInt("quante frazioni vuoi inserire? ");

//creazione frazioni in base al numero immesso
for (numF = 0; numF<10; numF++)


non so come gestire la frazione usando un ciclo for.
Per creare una frazione di solito: usiamo la classe "Frazione", in questo modo:
num = tastiera.readInt("Numeratore frazione ");
den = tastiera.readInt("Denominatore frazione ");

Frazione uno = new Frazione(num, den);
Frazione due = new Frazione(num, den);

grazie a chi mi aiuterà ;)


edit:
ps: avevo fatto una cosa del genere, ma mi sembrava un delirio totale :eekk:
new Frazione((tastiera.readInt("Inserisci num e den").(num, den)));

[ndakota]

for(int i = 0; i < numF; i++) {

int num = tastiera.readInt("Numeratore frazione ");
int den = tastiera.readInt("Denominatore frazione ");

Frazione f = new Frazione(num, den);
}


Chiaramente se devi tenerle in memoria per farci qualche operazione successivamente potresti per esempio salvarle in un array.


Frazione[] frazioni = new Frazione[numF];

for(int i = 0; i < numF; i++) {

int num = tastiera.readInt("Numeratore frazione ");
int den = tastiera.readInt("Denominatore frazione ");

frazioni[i] = new Frazione(num, den);
}

[djadry]

ok il definitivo è
Frazione[] frazioni = new Frazione[numF]; //creo l'array per memorizzare le frazioni che inserirò

for (int pos = 0; pos < numF; pos++) {

int num = in.readInt("Numeratore? ");
int den = in.readInt("Denominatore? ");

frazioni [pos] = new Frazione(num, den);

}
for (int pos = 0; pos < frazioni.length; pos++)
out.println(frazioni[pos].toString());
}
}

ho sostituito i con pos perchè il manuale mi consigliava di fare così per capire meglio il funzionamento di un array. comunque ora ci sono, proverò a fare varie operazioni come somma o moltiplicazione.

ti ringrazio di nuovo :)