Newsgroup: it.comp.java
Titolo: leggere dati da tastiera

Ciao a tutti. Sono al quarto anno di perito informatico, l'hanno scorso ho 
studiato il C, e ora sto iniziando con Java (prima lezione, per ora ho 
scritto il classico "hello world"). Vorrei iniziare a scrivere qualcosa di 
più """elaborato""", tipo somma di due interi, ma come faccio ad acquisire 
dati da tastiera? Vorrei conoscere lo standard del linguaggio, non 
utilizzare una classe scritta da qualcuno per uso personale. Grazie in 
anticipo.


wrote:

Mi piace il tuo stile, insomma non sie il classico studente che tira a
fare il meno possibile..
import java.util.Scanner;
...
        Scanner in = new Scanner(System.in);
        System.out.println("come ti chiami?");
        String name  = in.next();
        System.out.println("inserisci due numeri " + name);
        int x = in.nextInt();
        int y = in.nextInt();
        //System.out.println("scrivi qualcosa");
        //String c = in.nextLine();
        System.out.println("il risultato e' " + (x + y));
Nota le righe che sono commentate.. sono li' per farti notare che i
vari metodi nextInt o next ignorano il return che tu dai ogni volta
che inserisci nuovi dati. Quindi devi fare attenzione perche se usi un
nextLine  dopo un nextInt, la tua nextLine si legge il return che tu
avevi dato dopo l int...quindi fai attenzione a sto piccolo
trabocchetto che ti puo' far perdere del tempo...(nextLine invece si
legge tutta la stringa che hia dato prima del return , e si mangia il
return finale)
buon lavoro! :)


Il modo probabilmente più comodo è importare javax.swing.JOptionPane e
usare JOptionPane.showInputDialog / JOptionPane.showMessageDialog per
input e output.
-- 
"The problem of viruses is temporary and will
be solved in two years."   -- John McAfee, 1988
~> 
http://www.wysinnwyg.com/

> iniziare a scrivere qualcosa di piů """elaborato""", tipo somma di


 come si fa ad imparare delle istruzioni così lunghe?!
Anche qui dimostri di avere buon senso. E' vero che Java e' piu'
macchinoso di C. Ci sono varie ragioni per questo.
Una e' che i creatori di Java volevano un linguaggio che fosse magari
piu' verboso ma piu' chiaro e semplice e "comunicativo" del C.
L'idea e' che mentre C e' nato per creare UNIX e quindi per essere
efficente e compatto, Java e gli altri linguaggi ad oggetti sono nati
per creare programmi di grosse dimensioni ma di tipo gestionale,
quindi che devono essere scritti anche da programmatori non
superskillati e soprattutto devono essere modificati ed estesi da
programmatori che hanno cominciato a lavorare su quel programma da una
settimana..In sostanza Java senza programmazione ad oggetti non ha
nessun senso, e' solo un brutto C, ma spero che il tuo insegnante ti
fara' presto capire tutti i vantaggi che ti offre la programmazione ad
oggetti. Tinei presente che la programmazione ad oggetti e' stata
inventata principalmente per un motivo. Rendere i programmi facilmente
comprensibili, estendibili e modificabili modificando il codice
esistente il meno possibile.
Tieni anche presente che il bravo programmatore Java non e' quello che
conosce tutte le API a memoria... non devi ricordare tutto, per quello
c'e' il javadoc, e le ide come eclipse o netbeans aiutano
moltissimo... quello che devi aver chiaro e' come usare la
programmazione ad oggetti come fare il design del tuo programma e
quali API ti possono essere utili.
Vedrai che ti divertirai :)
Come chicca finale guarda questo, una nota dal sito di Cay Horstmann
( autore di Core Java, un libro che ti consiglio...)
********************************************************************************************************
The March of Progress
1980: C
    printf("%10.2f", x);
1988: C++
    cout << setw(10) << setprecision(2) << showpoint << x;
1996: Java
    java.text.NumberFormat formatter =
java.text.NumberFormat.getNumberInstance();
    formatter.setMinimumFractionDigits(2);
    formatter.setMaximumFractionDigits(2);
    String s = formatter.format(x);
         for (int i = s.length(); i < 10; i++)
                 System.out.print(' ');
   System.out.print(s);
2004: Java
    System.out.printf("%10.2f", x);
***************************************************************************************************************************************

 esistente il meno possibile.
???
si puo' fare la stessa cosa col C, che non e' ad oggetti.
Ciao Jack
-- 
Eroi non si nasce, ti incastrano
- Jim Belushi

 Java deriva dal Lisp, non dal C.
Davvero? La scorsa settimana ho scaricato i sorgenti di maxima (un cas
scritto appunto in lisp) per aggiungere una funzione... Ebbene ho
chiuso subito l'editor. Il lisp è profondamente diverso dal java,
almeno nella sintassi.
Infatti direi che il java deriva dal C++ e nasce per togliere le cose
pericolose del C++ (aritmetica dei puntatori, ereditarietà
multipla...)
--
Ciao Neo

 wrote in news:c35f1aa7-c883-45da-8c8b-240a3f9c6bc5
@
k37g2000hsf.googlegroups.com
:

no. deriva dal lisp. ad esempio l'ereditarieta' delle classi segue quella 
del lisp e non quella del c++.
la sintassi e' la cosa meno importante in un linguaggio di programmazione.


 
Java prende una serie di idee da alcuni linguaggi precedenti.
Nello stesso link
http://en.wikipedia.org/wiki/Java_(programming_language)
che tu hai fornito puoi leggere
Influenced by 	
  * Objective-C,
  * C++,
  * Smalltalk,
  * Eiffel[1],
  * Ada 83,
  * Mesa[2],
  * Modula-3 [3]
-- 
Andrea Francia
http://www.andreafrancia.it/

 Ciao Jack
--
Ciao Neo


Formalmente, secondo il corso di Lingaggio e traduttori, un linguaggio è 
definito dalla sintassi.
In realtà la sintassi senza la semantica serve a ben poco.
Per tornare al discorso dell'importanza della sintassi sono d'accordo 
che non sia importante come la semantica ma una certa importanza ce l'ha.
Java ha avuto un aiuto molto importante dal tipo di sintassi usata.
C'erano molti programmatori C e/o C++ al momento dell'uscita di Java 
1.0, se Java foste uscito una sintassi esotica e con un modello ad 
oggetti esotico se lo sarebbe filato molta meno gente.
Anche i creatori di PHP hanno sfruttato la sintassi {}; per far sembrare 
meno piu' facile da imparare.
Nel caso di Java (come di PHP) la sintassi ha avuto soprattutto una 
funzione "commerciale" per ridimensionare la diffidenza dei 
programmatori per un nuovo linguaggio.
-- 
Andrea Francia
http://andreafrancia.blogspot.com/2008/07/colinux-linux-dentro-windows.html

 del lisp e non quella del c++.
Non conosco bene il LISP (ho usato solo un po' il JESS) ma dalla pagina 
su Wikipedia non mi sembra di capire che sia un linguaggio object oriented.
http://en.wikipedia.org/wiki/Lisp_programming_language
Non ti sei confuso con qualcos'altro?


 Java deriva dal Lisp, non dal C.
Secondo 
http://www.levenez.com/lang/history.html#07
Java fu generato da Oak che fu generato da Objective-C, Ada 83, Arm C++, 
  Eiffel2, Cedar, SmallTal80, Scheme 84.
Alla fine tutti (o quasi) hanno come prozio l'algol che fu generato da 
nonno Fortran.


del lisp e non quella del c++.
Certo, se il LISP avesse le classi.

 Non so proprio in che cosa Java deriverebbe dal LISP.
Ecco mi pareva...
--
Ciao Neo

 Certo, se il LISP avesse le classi.
e' saltato fuori qua dentro tempo fa.
l'ereditarieta' in Java non funziona come in C++ ma come nel Lisp.


 l'ereditarieta' in Java non funziona come in C++ ma come nel Lisp.
Il principio di infallibilit� del newsgroup! Istituito con il concilio 
vaticano secondo.


 ma come nel Lisp.
Per quanto ne so, il LISP, almeno escludendo eventuali dialetti
recenti, *NON HA* classi.
Attendo comunque un tuo esempio. Sono disposto ad imparare qualcosa di
nuovo.

 nuovo.
c'e' stata un'ampia discussione qua dentro tempo fa. google sono sicuro ti 
aiutera' a trovarla.


 aiutera' a trovarla.
Tocca a te dimostrare che la tua affermazione è valida non agli altri.
Per quel che mi riguarda, a meno di non ricevere smentite, hai detto una 
cosa che non sta ne in cielo in terra.


 
io ti ho detto dove trovare la dimostrazione, se non hai voglia di cercare 
sono cavoli tuoi.


 sono cavoli tuoi.
L'hai detto al mio omonimo, non a me. Non ha senso cercare una cosa che 
non c'�.


Forse il fatto � che in c++ esiste l'ereditariet� multipla.
cosa che in Java non c'�.
Non so � una mia interpretazione, non so se volevi dire questo


Secondo me non sapeva neanche lui cosa voleva dire.
Si ricordava vagamente qualcosa detto su questo newsgroup e 
probabilmente ha confuso il linguaggio di cui si parlava.


aiutera' a trovarla.
Dai troppi pochi elementi perché si possa cercare alcunché.
Piuttosto, che problema hai nel riassumere il discorso?
Dal mio punto di vista, e a beneficio dell'OP che legge, ti dico che
nell'affermare che Java deriva dal LISP stai dicendo un'enorme
sciocchezza. Ora dimostrami che non è vero.

sono cavoli tuoi.
Dacci un puntatore alla discussione.

 sono cavoli tuoi.
Post Scriptum: ho cercato su Google Groups i thread di questo gruppo con
le keyword "java ereditarietą lisp" e non viene fuori un bel nulla di
recente, a parte questo thread. Quindi credo sia doveroso da parte tua
dare qualche spiegazione :-)
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

 dare qualche spiegazione :-)
Leggo su wikipedia che il Common LISP ammette il paradigma orientato
agli oggetti. Naturalmente non ho la più pallida idea di come lo
faccia.
http://it.wikipedia.org/wiki/Common_LISP
--
Ciao Neo

Andrea Laforgia <a.laf...@andrealaforgia.it.invalid> wrote in 
news:1e2ld4doq7j5i8dio...@4ax.com
:

trovato:
<
http://groups.google.com/group/it.comp.java/browse_frm/thread/db7efa78bf09
7938/4712ef7f918f919f?lnk=st&q=group%3Ait.comp.java+author%3AJack#>
Addio Jack


Dai su calma ragazzi!
Una piccola precisazione prima di scrivere. Lisp non è un linguaggio,
ma una famiglia di linguaggi (questa cosa mi è costata l'esame di
Linguaggi di programmazione qualche mese fa...). Common Lisp, Scheme e
simili sono linguaggi che appartengono alla famiglia LISP.
Quindi, da quello che so io (non voglio che la cosa si a presa come
verità assoluta), il Common Lisp è un linguaggio funzionale in cui
programma e dati sono la stessa identica cosa e che permette di essere
usato sia in modalità consona al linguaggio, cioè valutazione di
espressioni e funzioni, oppure può essere utilizzato in modalita
object oriented attuando sempre la valutazione secondo la logica del
prim'ordine di espressioni e funzioni.
Non chiedetemi però come lavora Common lisp in dettaglio quando lo si
usa in modalità OO perchè non ho mai avuto il tempo per
approfondire...
L'obiettivo finale della creazione di Java oltre ad essere quello di
creare un linguaggio ad alta portabilità per sviluppare su piattaforme
era l'obbligare i programmatori ad astrrre a livelli nettamente più
alti rispetto a quelli del C e derivati. Goesling infatti ha spesso
detto che Java non voleva solo attirare su di se i programmatori C/C++
ma voleva anche avvicinarli al ragionamento in LISP.
Infatti in Java il ragionamente in essere paragonato a quello del lisp
ma solo fino ad un certo punto, e questo poichè Java non è funzionale
e non gode delle proprietà di purezza derivate dalla rigorosità della
trasparenza referenziale presente in LISP.
Che poi Java abbia subito influenze un pò da qualsiasi linguaggio, C e
C++ in primis, è solo per accaparrarsi un maggior bacino di
svilupaptori-utilizzatori nel primo periodo.
Per restare in tema della vicinanza con il lisp si pensi che nel JDK 7
si era parlato dell'introduzione delle enclosures e cioè quello che
dovrebbe essere l'equivalente delle funzioni anonime (chiamate anche
lamba expression in LISP e derivati e soprattutto cosa di cui io,
nella mia ignoranza, non ho mai capito l'utilità).
Ovviamente la conclusione è una ima opinione personale quidi niente
lapidazione please.
Concludo quindi dicendo che Java tenta di unire l'incredibile potenza
del ragionamento sulla base dei linguaggi LISP alla potenza
computazionale dei linguaggi  C/C++. Java è un miscuglio di linguaggi
che sa dare molte soddisfazioni.
Una tazzina di Java per favore!
PS per chi non lo sapesse Java è anche un aqualità di caffè, certo che
Goesling ha una fantasia con i nomi.....

 Goesling ha una fantasia con i nomi.....
C'e' anche un isola che si chiama Java, ma il nome italiano è Giava.


 C'e' anche un isola che si chiama Java, ma il nome italiano è Giava.
Evviva!!! Comunque secondo la "leggenda" Goesling scelse per il
linguaggio Oak questo nome poichè l aprima cosa che Goesling vide
fuori dalla finestr era dove stavano definendo le specifiche era,
appunto, una quercia (in Inglese Oak)....
Con Java la storia fu simile, Goesling rivide la quercia però dato che
Oak era già stato brevettato e dato che Java non c'entrava nulla con
quel linguaggio Goesling si guardò in giro ancora. Vide la sua tazzina
del caffè, indovinatene la qualità.....
Seiya

Ho studiato al programmazione funzionale, e con essa il Lisp (o meglio
il suo dialetto SCHEME) ai tempi dell'università (http://
en.wikipedia.org/wiki/Functional_programming
).
Il corso si chiamava 'Linguaggi Speciali di Programmazione' ed era
strutturato per offrire una panoramica comparativa su un insieme di
paradigmi di programmazione, prendendo per ciascun paradigma uno o più
linguaggi di programmazione che lo incarnassero:
C++: Object-Oriented (
http://it.wikipedia.org/wiki/
Programmazione_orientata_agli_oggetti)
SmallTalk: Object-Oriented (probabilmente il linguaggio che interpreta
il paradigma Object Oriented nella maniera più pura)
Modula: imperativo, derivato del Pascal, che introduce impiego dei
moduli per decomporre il programma in moduli distinti che mascherino
l'implementazione offrendone solo il contratto di interfaccia (http://
en.wikipedia.org/wiki/Modularity_(programming)
)
Scheme: funzionale
ML: funzionale
Prolog: logica (
http://it.wikipedia.org/wiki/Prolog
)
Java appartiene alla categoria dei linguaggi di programmazione Object
Oriented. Non ha nulla a che vedere con il Lisp.
Di recente si sta discutendo se inserire in Java il meccanismo delle
'chiusure' (
http://en.wikipedia.org/wiki/Closure_(computer_science)
),
caratteristica propria delle programmazione funzionale (e quindi anche
di Lisp): questo è l'unico elemento in comune che i due linguaggi
potrebbero in futuro avere. Ma i paradigmi sono e resteranno
profondamente diversi.
Lisp non ha classi semplicemente perché il paradigma che incarna (il
funzionale) semplicemente non ha il concetto di 'oggetto' che il
concetto di classe serve a descrivere.
Ciao
Daniele

7938/4712ef7f918f919f?lnk=st&q=group%3Ait.comp.java+author%3AJack#>
Letto.
Non si dice affatto che Java deriva dal LISP ma, al limite, che alcuni
concetti prendono una vaga aspirazione da esso (una cosa è che un
linguaggi DERIVI da un altro, una cosa è che ne colga qualche spunto).
E non si parla affatto dell'ereditarietà come DERIVATA dal LISP o che
funzioni diversamente dal C++. Queste sono panzane inventate dalla tua
fervida fantasia. D'altronde, la questione è ovvia a chi abbia
conoscenze e di C++ e di Java e di LISP.

nella mia ignoranza, non ho mai capito l'utilità).
Nessuno mette in dubbio che ogni linguaggio di programmazione si
ispiri ad altri linguaggi più o meno passati. Quindi è lecito che Java
si *ISPIRI* al LISP. Ma da qui a dire che questo linguaggio *DERIVI*
dal LISP o che l'ereditarietà funzioni in maniera sostanzialmente
diversa che in C++ ed anzi come in LISP, ce ne passa. Java non è
ovviamente *DERIVATO* dal LISP e benché il modello ad oggetti abbia
diverse differenze, l'ereditarietà funziona sostanzialmente come in
C++.


Cazzo! Lo sapevo di essere stato stampato solo per lo spirito sportivo
di voler bocciare qualcuno.....
:D
Anche perchè non si sa come mai ma se l'esame è strutturato in 3 parti
e non prendi la sufficenza in una vieni stampato. Bocciati con un 24 è
memorabile....
Vabbè lasciamo perdere. Per fortuna che poi l'ho passato al giro
successivo quel maledetto esame!
Scusate L'OT
Seiya

 C++.
forse ho dimenticato i doppi apici al termine vicinanza... :D
Con il mio post infatti non volevo dire che Java derivi dal Lisp, ma
che gli ideatori di Java volevano che questo predesse una delle
migliori caratteristiche del Lisp cioè il modo di pensiero
estremamente pulito.
Sull'ereditarietà Java e quella  C++ qualche differenza mi sembra di
vederla.
In C++ l'ereditarietà è multipla e in certi casi molto particolari può
portare a errori, mentre Java l'ereditarietà è singola può
trnquillamente emulare quella multipla tramite l'utilizzo delle
interfaccie. Poi non sapendo molto di C++ potrei anche sbagliarmi.
Ciao Seiya

 
Se la domanda non è indiscerta: che corso fai?



Alla fine avevi quasi ragione nel dire che LISP aveva le classi, ci 
mancava solo il "Common" davanti. Grazie a te abbiamo imparato che il 
Common LISP e multiparadigma e il LISP solo funzionale.
Sul fatto che Java sia derivato dal Common LISP non mi esprimo, mi 
sembra piu' probabile che abbia preso delle idee, come ne puo' aver 
preso altre da altri linguaggi. In rete non ho ancora trovato un testo 
esaustivo, chiaro e semplice che spieghi come sono confluite le idee di 
altri linguaggi in Java.


 wrote in
news:gbgfb9$488$
1...@aioe.org
: 

Se guardi il thread sopracitato potrebbe darsi che ci sia un link verso 
un documento di uno degli autori di Java che racconta come e perche' e' 
nato Java. Se non ricordo malissimo spiega anche la faccenda del _Common_ 
LISP.
O forse era da qualche altra parte...mah...
Ciao Jack
