[Java] Spiegazioni basilari

[Alemix]

Salve a tutti, ho da poco incominciato a scuola la programmazione ad oggetti passando dal c al java, sto capendo ben più poco.
Ho cercato più volte di farmi spiegare dal prof bene come funziona la prog ad oggetti, però dopo mesi non capisco...
Vi dico che io quando lavoravo in c ero tra i primi della classe (non per vantami, ma è solo per farvi capire che non ho basi) e ora non capirci niente mi scoccia tanto. Il casino penso che sia perchè ho cambiato il prof, ma ora non dilunghiamoci troppo e andiamo ai miei problemi:

per prima cosa non capisco se il Java deve lavorare con più classi oppure se gliene basta una sola, a scuola noi di solito usiamo sempre 2 classi minimo e diciamo che secondo me incasina per le prime volte.
secondo, scuola il prof ci ha fatto fare un programma che calcola dei punti x e y e fa le coordinate del punto, è un programma stupido, almeno in c lo saprei fare ad occhi chiusi ma qua mi incasino
Prima classe Cordinate

class Cordinate
{
	double x;
	double y;
	
	public Cordinate (double xi, double yi)
	{
		x=xi;
		y=yi;
	}
	public double getX()
	{
		return x;
	}
	
	public double getY()
	{
		return y;
	}
	
}

diciamo che fin qua non ci sono grossi problemi, però la cosa che non mi torna sono i get, allora a noi a scuola il prof ci ha sempre parlato di set variabile e get variabile, però non penso che sia il solo nome e penso che ci siano altri metodi.
Cmq qua se ho capito bene si crea la classe, si inizializzano 2 variabili x e y e poi spuntano sti get, allora all'interno ci sono dei return, cioè ogni volta che noi richiamiamo il getX (per esempio) cosa succede? in c si usava o lo scanf o il cin e si leggeva l'input ma qua non capisco

seconda classe

class Retta
{
	static final int Dim=100;
	private Cordinate[] vett = new Cordinate[Dim];
	
	public Retta(double k, double c, float step)
	{
		double xi = (double)-100*step/2;
		double yi;
		for (int i=0;i<Dim;i++)
		{
			yi=k*xi+c;
			vett[i]= new Cordinate(xi,yi);
			xi=xi+step;
		}
	}
	public Cordinate getCoordRett(int i)
	{
		if(i<1||i>100)
			return null;
		else
			return vett[i-1];
	}
}

eccoci alla marea di casini che mi ritrovo, vediamo se capisco alla perfezione...
si inizializza la classe, si fa una variabile statica con static final che è la dimensione del nostro array,ed eccoci al mio incubo i COSTRUTTORI e soprattutto il new, non capisco a cosa servono, ed a new non ci trovo una minima logica, cioè si crea se ho capito un array Cordinate (Cordinate[]) da Cordinate[Dim]?
Poi creiamo il metodo retta, con all'interno le 3 variabili, fin qua ho capito tutto tranne quel double tra parentesi.
Il public Cordinate getCoordRett non ne ho la minima idea

e infine l'ultimo

import java.lang.*;
class TestRetta
{
	public static void main(String[]args)
	{
		Retta r= new Retta(1.0,0.0,0.5f);
		
		for (int i=1;i<=100;i++)
		{
			if (i%5==0&&i!=0)
				System.out.println(r.getCoordRett(i).getX() +","+ r.getCoordRett(i).getY());
			else
				System.out.print(r.getCoordRett(i).getX() +","+  r.getCoordRett(i).getY()+ "   ");
		}

	}
}

qua non ho capito la prima parte, cioè il public static void main è la classe main cioè la principale no? il new è un incubo, poi quei valori tra parentesi cosa stanno a signifiicare, poi vabbè l'if serve solo per far vedere tutte e 100 le cordinate che se no non vengono visualizzate nella pagina

Scusatemi se sono lungo e noioso, e se molti non vorranno leggere il tutto e spiagarmelo li capisco... ma se scrivo qua su queste cose è perchè dal mio prof non ho ancora capito... spero che possiate aiutarmi!

[khelidan1980]

secondo me prima di tutto dovresti chiarirti bene cosa è la programmazione ad oggetti,al di là del linguaggio,il new serve proprio a creare un oggetto,che è un'astrazione di quello che tu vuoi rappresentare del mondo reale,infatti l'oggetto punto ha le sue coordinate,che poi tu andrai a cambiare ecc...con i metodi get,set ecc....ti consiglio di dotarti di un buon libro visto che i risultati della spiegazione del prof sono questi

[Alemix]

allora ma supergiù cos'è la programmazione ad oggetti l'ho capita, ma il new no, avevo capito che il new crea un oggetto, in questo caso un attributo (almeno spero, ho il terrore che sia la risposta sbagliata) però da cosa lo crea non capisco
per fare un esempio in C

int Pincopallino[100];

così creo un array ma con il new non lo capisco

[khelidan1980]

ma questo codice te lo hai scritto il prof?

[andbin]

Originariamente inviato da Alemix

per prima cosa non capisco se il Java deve lavorare con più classi oppure se gliene basta una sola

Non è una questione e non devi farti questioni sul "numero" di classi. Nella programmazione ad oggetti, ogni classe dovrebbe rappresentare una entità ben precisa e dovrebbe essere realizzata per avere una alta "coesione", cioè essere "focalizzata" su un ben preciso e unico scopo.

Originariamente inviato da Alemix

Prima classe Cordinate
diciamo che fin qua non ci sono grossi problemi, però la cosa che non mi torna sono i get, allora a noi a scuola il prof ci ha sempre parlato di set variabile e get variabile, però non penso che sia il solo nome e penso che ci siano altri metodi.

Questa classe Cordinate va bene. I dati di istanza non sono perfettamente "incapsulati" (hanno livello di accesso di "default") ma non stiamo ora a fare i pignoli.

Certo che ci possono essere altri metodi. Ma è in base al "design" della classe che stabilisci quanti/quali metodi definire. In Java è tipico realizzare quelli che si chiamano "JavaBean", ovvero delle classi che per definizione, hanno delle "proprietà". Le specifiche JavaBean (a parte le questioni più complesse), dettano delle semplici regole a livello di denominazione dei vari metodi per definire come accedere alle proprietà (più altri per il listener ecc... ma tralasciamo).

Ad esempio la regola è che se la classe ha una proprietà "nome", allora ci può essere un metodo getNome e uno setNome. Se la proprietà è di tipo String, i metodi saranno:

public String getNome() { .... }
public void setNome(String n) { .... }

Originariamente inviato da Alemix

Cmq qua se ho capito bene si crea la classe, si inizializzano 2 variabili x e y e poi spuntano sti get, allora all'interno ci sono dei return, cioè ogni volta che noi richiamiamo il getX (per esempio) cosa succede? in c si usava o lo scanf o il cin e si leggeva l'input ma qua non capisco

Una cosa è leggere le proprietà di un oggetto e un'altra cosa è chiedere in input qualcosa all'utente.

Se vuoi chiedere in input qualcosa all'utente, devi usare classi e metodi di I/O appositi.
Ti chiedi che succede con getX(). Se hai creato un oggetto di tipo Cordinate (creato passando nel costruttore i due valori), invocando il getX() su quell'oggetto ottieni semplicemente il valore della proprietà 'x' di quell'oggetto. Tutto qui. Non centra nulla con interfacce utente o altro.

Originariamente inviato da Alemix

seconda classe

class Retta
{
....
}

eccoci alla marea di casini che mi ritrovo, vediamo se capisco alla perfezione...
si inizializza la classe, si fa una variabile statica con static final che è la dimensione del nostro array,ed eccoci al mio incubo i COSTRUTTORI e soprattutto il new, non capisco a cosa servono, ed a new non ci trovo una minima logica, cioè si crea se ho capito un array Cordinate (Cordinate[]) da Cordinate[Dim]?

Questa classe mi sembra pure ok ... non ho controllato nel dettaglio i vari calcoli .....

Comunque quel:
private Cordinate[] vett = new Cordinate[Dim];

è corretto. Gli array sono degli oggetti e vanno pertanto istanziati. Quella è la forma corretta per istanziare un array di 'Dim' elementi. Nota che l'array contiene inizialmente 100 null. Non hai creato 100 oggetti di tipo Cordinate, hai solo creato un array che contiene 100 locazioni di tipo reference Cordinate.

Originariamente inviato da Alemix

Poi creiamo il metodo retta, con all'interno le 3 variabili, fin qua ho capito tutto tranne quel double tra parentesi.

Quel double tra parentesi è un "cast", una conversione esplicita. Ma è pure superfluo. Infatti 'step' è float, -100 e 2 sono costanti intere, tutta la espressione viene calcolata come float (c'è una conversione implicita dei due valori da interi a float) e il risultato verrebbe poi convertito implicitamente a double (senza quel cast).

Originariamente inviato da Alemix

Il public Cordinate getCoordRett non ne ho la minima idea

La classe Retta contiene 100 coordinate. Al metodo getCoordRett si passa un indice (è 1-based ma non importa) che permette di restituire la coordinata i-esima richiesta.

Originariamente inviato da Alemix

qua non ho capito la prima parte, cioè il public static void main è la classe main cioè la principale no?

No, main() è il metodo statico invocato dalla JVM come punto di partenza della applicazione.

Originariamente inviato da Alemix

il new è un incubo

Il new serve sempre per istanziare un oggetto.

Originariamente inviato da Alemix

poi quei valori tra parentesi cosa stanno a signifiicare

Quelli dopo new Retta?? Sono gli argomenti che vengono passati al costruttore.

[xblitz]

Allora la OOP cerca di riflettere le cose così come sono nel mondo reale ovvero un insieme di oggetti che comunicano tra loro per risolvere un problema (esepio idiota: un pc è formato da più oggetti semplici che dialogano tra di loro per svolgere un determinato compito)

Questi oggetti tuttavia non sono definiti uno per uno, si definiscono invece le caratteristiche (le proprietà o attributi che poi sono la stessa cosa delle variabili della procedurale) e le funzionalità che l'oggetto offre (metodi che sarebbero le funzioni della procedurale funzioni). Per esempio per creare un oggetto motocicletta non si crea la motocicletta avente il colore rosso, di marca x e targa y ma si crea la classe che fa da modello astratto: quindi si crea una classe che abbia al suo interno un attributo per il colore, uno per la targa e uno per le ruote. Tali attributi se non venissero inizializzati non si potrebbe usare la classe o meglio: non viene generato nessun errore, però pensa di avere una motocicletta senza serbatoio... Il costruttore serve proprio a questo: a inizializzare gli attributi della funzione.

Per quanto riguarda il main banalmente: in Java in tutto è una classe e quindi anche il main (che è una funzione) deve essere inglobato in un oggetto.... la sua definizione è quella da te postata (in pratica ci devono essere necessariamente gli attributi public e static)

Spero di esserti stato utile
ciao

[m.distrutti]

cerco di aggiungere quello che non ti e' stato spiegato ancora in base alle tue richieste, cmq ti consiglio pure io un buon libro di introduzione vedi topic relativi.


come ti hanno già detto giustamente la classe rappresenta l'astrazione di quello che vuoi rappresentare e l'oggetto la sua concretizzazione,da quì il termine istanziare la classe

e' come definire una classe Persona per poi creare oggetti di tipo Persona con nome marco luca etc...(il nome sarebbe appunto l'attributo)

scusa se magari divento pignolo,forse ti sei espresso male te e non c'e' bisogno di spiegazione, ma penso sia cmq piu corretto correggerti qui :

si fa una variabile statica con static final

qui non crei una variabile statica con static final ma dichiari una variabile statica e finale nel senso che realizzi una costante statica, final indica che il valore di inizializzazione e' il valore finale poichè essendo appunto una costante non può mutare

qua non ho capito la prima parte, cioè il public static void main è la classe main cioè la principale no

no e' un metodo, e' l'entry point dell'applicazione che come ti hanno gia detto e' il metodo che viene eseguito dalla JVM

per quanto riguarda lo static probabilmente essendo passato da poco dal C sarai abituato a pensare in C e non in Java...

una variabile statica in C come sai gia e' una variabile la cui visibilità e' ristretta al blocco di codice nella quale viene dichiarata ma la sua esistenza in memoria rimane fino alla chiusura dell'applicazione(e' come una global ma a scope limitato per le var locali)
se dichiari una variabile locale e statica in un blocco {...} (qualunque sia la funzione o procedura relativa) quella variabile e' raggiungibile solo da quel blocco,ovviamente richiamando quel blocco piu di una volta ogni volta che viene letto o aggiornato il valore bisogna sempre tener conto che la variabile non viene mai distrutta percio il suo valore non viene mai perso
se dichiari una variabile globale statica la variabile sarà accessibile solo da quel file

in Java invece e' differente, prima di tutto essendo il paradigma differente si chiama membro statico sia esso un attributo o metodo.(le variabili all'interno dei metodi non possono essere statiche perchè non sono ne attributi ne metodi)

se un membro e' statico significa che può essere accessibile senza dover per forza istanziare la classe a cui appartiene, ovvero non hai bisogno di un oggetto attivo(oggetto che ha istanziato la classe)

static final int Dim=100;

System.out.println(Retta.Dim); //codice lecito in quanto e' un membro statico

il metodo statico e' uguale, ovvero e' accessibile senza che tu debba istanziare la classe percio supponendo di avere una semplicissima classe Persona con metodo statico public static int getNumFingers(){...}
fare :

System.out.println(Persona.getNumFingers);

e' lecito

mi e' piu semplice ora spiegarti che un membro statico e' un membro di classe e non di oggetto, se dichiari un membro statico tutte le istanze della classe contente tale membro lo condivideranno(e' unico per tutte le istanze, di fatti tutte le persone che puoi creare nel tuo programma hanno un unico metodo getNumFingers() ....e spero restituisca sempre 5 )

questo e' il motivo credo per il quale il main che sarebbe l'entry point dell'applicazione deve essere implementato statico, poiche la JVM non istanzia la classe principale (ovvero quella nella quale hai definito il main) per eseguire il tuo programma ma esegue, appunto, senza l'ausilio di oggetti attivi il main e deve essere pubblico perchè lo fa al di fuori dalla classe nella quale viene definito ...purtroppo a riguardo non sono mai riuscito a trovare conferma in nessun libro o da professori ma credo sia per logica cosi.

per finire il costruttore. non sono un incubo dopo di tutto
quando istanzi una classe il costruttore e' una procedura(la definisco tale in quanto non restituisce nulla) che rappresenta l'inizio del ciclo di vita del tuo oggetto e serve in molti casi ad inizializzarlo[in altri linguaggi come il c++ c'e' anche un distruttore che rappresenta la propria fine prima di essere distrutta]

nel caso di prima se definisco la classe Persona come:

class Persona{
        public String nome;
}

quando creo : Persona Studente1 = new Persona();
creo un oggetto Studente1 ma senza nome,perche inizialmente non viene inizializzato il relativo attributo

se invece :

class Persona{
        public String nome;

        public Persona(String nomeP){
                nome = nomeP;
        }
}

Persona Studente1 = new Persona("Luca");
creo una persona passando la stringa "Luca" al costruttore che assegna essa(la stringa "Luca") al membro pubblico nome percio si puo dire che creo una persona di nome Luca.prova a debuggare il programma per vedere come il flusso di codice viene eseguito.

spero di non aver scritto castronerie e di averti piu o meno fatto capire un po di cose


EDIT:PS:

in questo caso un attributo (almeno spero, ho il terrore che sia la risposta sbagliata)

con il new non crei attributi ma prepari la memoria all'allocazione del oggetto di tipo classe in questi casi

[k0nt3]

inizialmente potresti vedere gli oggetti come delle semplici struct che possono contenere anche funzioni (metodi) oltre a variabili (attributi). in questo modo è possibile invocare un metodo appartenente all'oggetto.
ma gli oggetti sono molto di più di questo perchè possono essere relazionati fra loro in vari modi. nell'esempio della retta (ad esempio) si nota che la retta possiede delle coordinate e questo ha molto senso direi. l'essenza della programmazione OO in poche parole è quella di cercare di modellare la realtà con opportune classi, non esiste il modello perfetto, ma esistono modelli migliori e modelli peggiori a seconda degli scopi.
passando a cose più pratiche.. la new in pratica è l'equivalente di malloc, solo che in java non viene esposta al programmatore tutta la parte relativa alla gestione della memoria, poichè (quasi sempre) se ne occupa java in automatico.
ma oltre ad allocare memoria la new invoca anche (immediatamente e in automatico) il costruttore dell'oggetto, motivo per cui le new hanno dei parametri (se i costruttori richiedono parametri).

[^TiGeRShArK^]

Originariamente inviato da Alemix

Salve a tutti, ho da poco incominciato a scuola la programmazione ad oggetti passando dal c al java, sto capendo ben più poco.
Ho cercato più volte di farmi spiegare dal prof bene come funziona la prog ad oggetti, però dopo mesi non capisco...
Vi dico che io quando lavoravo in c ero tra i primi della classe (non per vantami, ma è solo per farvi capire che non ho basi) e ora non capirci niente mi scoccia tanto. Il casino penso che sia perchè ho cambiato il prof,

Questo succede perchè devi completamente rimuovere tutto il modo di pensare procedurale (e quindi completamente sbagliato in ottica di programmazione ad oggetti) e imparare a programmare ad oggetti.
Il professore attuale non ha alcuna colpa.
Il vero problema è che hai iniziato a programmare col linguaggio peggiore esistente per iniziare.
questo thread lo metterei in rilievo in modo che finalmente tutti capiscano che iniziare col c è la scelta peggiore in assoluto.
Cmq io ti consiglierei vivamente di studiare BENE come funziona la programmazione ad oggetti e di cercare di cancellare tutto quello che hai imparato col c.

[k0nt3]

Originariamente inviato da ^TiGeRShArK^

Questo succede perchè devi completamente rimuovere tutto il modo di pensare procedurale (e quindi completamente sbagliato in ottica di programmazione ad oggetti) e imparare a programmare ad oggetti.
Il professore attuale non ha alcuna colpa.
Il vero problema è che hai iniziato a programmare col linguaggio peggiore esistente per iniziare.
questo thread lo metterei in rilievo in modo che finalmente tutti capiscano che iniziare col c è la scelta peggiore in assoluto.
Cmq io ti consiglierei vivamente di studiare BENE come funziona la programmazione ad oggetti e di cercare di cancellare tutto quello che hai imparato col c.

abbastanza discutibile, comunque per non "sporcare" il thread lascio l'ardua sentenza ai posteri

[vincenzo83]

Ciao Alemix, ti consiglio di leggere "Object Oriented && Java 5 - II edizione": scaricabile al seguente indirizzo: http://www.claudiodesio.com/ (...il libro è in italiano )
Letto con tranquillità dall'inizio, toglie tutti i dubbi.

[m.distrutti]

Originariamente inviato da ^TiGeRShArK^

Questo succede perchè devi completamente rimuovere tutto il modo di pensare procedurale (e quindi completamente sbagliato in ottica di programmazione ad oggetti) e imparare a programmare ad oggetti.
Il professore attuale non ha alcuna colpa.
Il vero problema è che hai iniziato a programmare col linguaggio peggiore esistente per iniziare.
questo thread lo metterei in rilievo in modo che finalmente tutti capiscano che iniziare col c è la scelta peggiore in assoluto.
Cmq io ti consiglierei vivamente di studiare BENE come funziona la programmazione ad oggetti e di cercare di cancellare tutto quello che hai imparato col c.

sinceramente sto cominciando a condividerlo anche io questo pensiero...e qualche mese fa ero tossico C
quoto

[Alemix]

Ragazzi, vi devo ringraziare esageratamente (per chi diceva che non era il prof penso che si sia sbagliato ) non dico di aver capito tutto, ci mancherebbe, però ho capito mooolto di più di prima.
Purtroppo il mio cervellino funziona via pratica e non con la teoria... io ho studiato da inizio novembre la teoria del OOP, senza capire, ma ora spiegandomi cosa fa quel programma sto capendo, quindi cominciamo a rispondere.

tante cose che ho scritte, le ho scritte di corsa e male (non che poi io sia una cima in Italiano )

khelidan1980, si lo ha scritto il prof per tutta la classe siccome non riuscivamo a farlo

la questione degli oggetti l'avevo capita (almeno quella) cioè sapevo che erano diversi dalle solite variabile, ma io le avevo prese come un mezzo miscuglio tra funzioni o procedure e record.

Allora ho capito il set e il get cioè in poche parole noi creiamo in set x, e poi in get gli assegniamo un valore, ma il valore quando se lo prende, cioè spieghiamoci meglio, se non ho capito male x diventa xi... ma quando c'è questo passaggio? e poi, se noi non diamo ad un attributo un numero, tipo 50 come facciamo a sapere che valore ha?
e altra cosa

       
                for (int i=0;i<Dim;i++)
		{
			yi=k*xi+c;
			vett[i]= new Cordinate(xi,yi);
			xi=xi+step;
		}
	}

perchè quando gli assegno a vett[i] l'attributo cordinate con il new e con 2 valori?

Per la questione del main avevo capito giusto ma mi ero espresso male.

Il new invece continuo a nn capire, il concetto teorico l'ho capito cioè i faccio new e la virtual machine mi alloca dello spazio in memoria ma prendiamo questo caso:

private Cordinate[] vett = new Cordinate[Dim];

il private sta per privato, cioè che è "nascosto" Cordinate[] sta per la classe? vett non so, il simbolo si = mi da pensare che sia un assegnamento, e Cordinate[Dim] è l'array

Per ora direi basta domande, poi massimo chiedo dopo
ora do un occhiata a quel libro, ma un buon libro cartaceo completo? che se è me lo prendo!

[khelidan1980]

il libro è sia in versione cartacea sia scaricabile liberamente online,è davvero un bel libro lo usate anche io!

Per la questione del new,tu hai capito semplicemente il concetto a basso livello,cosa che a te non interessa,cosa fa veramente new non lo hai capito,perchè ancora non hai chiaro il paradigma ad oggetti....hai una confusione bestiale in testa e a parer mio è l'esempio lampante,come dicono anche tanti altri più qualificati di me qui,che insegnare il C come primo linguaggio è quanto di più sbagliato ci sia!

[m.distrutti]

vett[i]= new Cordinate(xi,yi);
.......
perchè quando gli assegno a vett[i] l'attributo cordinate con il new e con 2 valori?

private Cordinate[] vett = new Cordinate[Dim];

in quest'ultimo quote viene dichiarato vett(che e' il vettore) e inizializzato per poter rappresentare 'Dim' oggetti 'Cordinate' (ma i reference nel vettore non sono ancora inizializzati)

con l'istruzione : vett[i]= new Cordinate(xi,yi); inizializzi vett[i] come oggetto attivo e passi al costruttore i parametri xi yi

EDIT: come dici te il new giustamente alloca in memoria, nel primo caso alloca un numero di reference non inizializzati,
nel secondo caso alloci un oggetto attivo passando il flusso di codice al proprio costruttore >_<'

sta cominciando a diventare una cosa personale farti capire il tutto >_<

[Alemix]

ihih, lo sto cominciando a pensare pure io
Però tornando al libro, ho visto che c'è quello cartaceo, lo sto scaricando e poi lo leggo, però mi servirebbe da portarmelo a scuola e sopratutto per non usare 500 fogli e litri di inchiostro per stamparmi le pagine

Cmq siccome mi avete detto che non ho capito il new, me lo potete spiegare sto cominciando a non capirci più nulla!

[khelidan1980]

tento di spiegarte prescidendo dal linguaggio ma conta che qui c'è gente molto piu brava che te lo spiegherà,il new serve per instanziare un oggetto....ora hai capito cos'è un oggetto?E che relazione ha con la classe?

[andbin]

Originariamente inviato da Alemix

Cmq siccome mi avete detto che non ho capito il new, me lo potete spiegare sto cominciando a non capirci più nulla!

È già stato detto nel thread (anche da me), che il new serve per istanziare oggetti nell'area di memoria che viene chiamata "heap".

Visto che conosci il C, facciamo un paragone, anche se non perfetto. Una classe la puoi paragonare ad una struttura.

Es.

struct prova {
    int var1;
    int var2;
};

Così non hai istanziato nulla, hai solo dichiarato come si chiama la struttura e cosa deve contenere. Non hai allocato nulla a livello di memoria.

Quando invece definisci una variabile, es:

int main (void)
{
    struct prova miavar;
    ....
}

Allora sì, in questo caso viene riservata della memoria (in questo caso in C è sullo "stack", non sul "heap") per una variabile che si chiama miavar di tipo struct prova e che occupa appunto quei tot di byte per i due int.


Quando in Java hai definito la classe Cordinate, non hai allocato un bel nulla, proprio come per le strutture.

class Cordinate
{
    ....
}

Quando fai new Cordinate(....) stai semplicemente chiedendo alla JVM di allocare un oggetto di tipo Cordinate. Nel "heap" verrà riservata una area di memoria di tot byte tali da poter contenere le variabili di istanza della classe, nel tuo caso quelle due variabili x e y di tipo double. Il new restituisce un "reference" a quell'oggetto.

Se le variabili di istanza non sono "troppo" protette (es. private), potresti anche fare:

Cordinate c = new Cordinate(....);
System.out.println (c.x);

La vedi la similitudine con le strutture???

Tutto qui.

[Alemix]

ahh capito, ho confuso le variabili con gli attributi... cioè io facevo il paragono tra attributi e variabili diciamo, e infatti non capivo... se ho compreso bene ho:

CLASSE
che è la classe dove io lavoro es: class Prova{...}

METODI
che è la parte dove io eseguo qualcosa es
class Prova
{
if(i=0)
else
}
ho fatto un esempio stupido senza inizializzare niente

ATTRIBUTI
che è la parte dove inizializzo le variabili
class Prova
{
public Prova p = new Prova;
}

attiributi e metodi stanno sullo stesso piano

e poi o le variabili infondo

Ditemi che ho capito

[m.distrutti]

Originariamente inviato da Alemix

ahh capito, ho confuso le variabili con gli attributi... cioè io facevo il paragono tra attributi e variabili diciamo, e infatti non capivo... se ho compreso bene ho:

CLASSE
che è la classe dove io lavoro es: class Prova{...}

METODI
che è la parte dove io eseguo qualcosa es
class Prova
{
if(i=0)
else
}
ho fatto un esempio stupido senza inizializzare niente

ATTRIBUTI
che è la parte dove inizializzo le variabili
class Prova
{
public Prova p = new Prova;
}

attiributi e metodi stanno sullo stesso piano

e poi o le variabili infondo

Ditemi che ho capito

T_T la terminologia procedurale scordala completamente qui

che è la parte dove io eseguo qualcosa es
class Prova{
if(i=0)
else
}
ho fatto un esempio stupido senza inizializzare niente

nu , prima di tutto non puoi realizzare un if dentro una classe cosi :S. Prova e' una classe e fin qui credo ci siamo capiti

in java e' cosi :

class nomeClasse{
     int attributo; //gli attributi stanno qui

     public nomeClasse(){
     //costruttore che ha lo stesso nome della classe non specifica nessun tipo 
     //di ritorno (ne void ne nient'altro per distinguersi dal resto)
     }

      void metodoVoid(){
         //*******EDIT*******
         int variabile
         //**********************
         if(...){
         ........
         }
      }//metodo che non restituisce nulla

      int metodoInt(){
      .......
      return attributo;
      }//metodo che restituisce un valore int

}

quelli che prima chiamavi funzioni o procedura ora si chiamano metodi
le variabili sono i dati che dichiari all'interno dei metodi o costruttore,anche i parametri passati...
gli attributi sono i dati dichiarati fuori dai metodi ma dentro la classe

EDIT:cmq e' inutile spendere 2000 post perche mi sembra chiaro che non hai molto le idee chiare >.<,se vuoi posso anche risponderti ma non vorrei confonderti le idee

penso sia piu esaustivo e preciso un libro o un ricevimento con il professore