[Java] Fare la stessa cosa con classe ereditata.. Help

[Balop]

ciao, vi scrivo quel era l'esercizio così per come l'ho avuto io:
Scrivere il codice di una classe Polinomio. Tale classe dovrà prevedere un costruttore in cui i coefficienti di un polinomio sono passati tramite un vettore di double. Dovrà essere implementata una funzione che restituirà il valore del polinomio in corrispondenza di un valore x passato come argomento. Scrivere il codice di una classe Polinomio2 in java che ereditando dalla classe Polinomio, implementi una funzione che restituisca il valore della derivata del polinomio in corrispondenza di un valore x passato come argomento.

Questo è quello che ho fatto io, però non ho usato l'ereditarietà come era richiesto dall'esercizio (vabbè ho usato pure interi al posto di double...):

public class Polinomio {
public void StampaFunzione(int v[]) {
for (int i = v.length - 1; i >= 0; i--) {
if (i > 1 && v[i] != 0) {
if (v[i] > 1)
System.out.print(v[i] + "x^" + i);
else
System.out.print("x^" + i);
}
if (i == 1 && v[i] != 0) {
if (v[i] > 1)
System.out.print(v[i] + "x");
else
System.out.print("x");
}
if (i == 0 && v[i] != 0)
System.out.println(+v[i]);
if (i >= 1 && v[i - 1] != 0)
System.out.print(" + ");
}
}

public void StampaDerivata(int v[]) {
for (int i = v.length - 1; i > 0; i--) {
if (i > 2 && v[i] != 0)
System.out.print((v[i] * i) + "x^" + (i - 1));
if (i == 2 && v[i] != 0) System.out.print((v[i] * i) + "x");
if (i == 1 && v[i] != 0)
System.out.print(v[i]);
if (i > 1 && v[i - 1] != 0)
System.out.print(" + ");
}
}

public void Funz(int v[], int x) {
int ris = v[0];
for (int i = 1; i < v.length; i++) {
int n = v[i] * x;
ris = ris + n;
x = x * x;
}
System.out.println(ris);
}

public void Derivata(int v[], int y) {
int ris = v[1];
for (int i = 2; i < v.length; i++) {
int n = v[i] * i * y;
ris = ris + n;
y = y * y;
}
System.out.println(ris);
}

public static void main(String[] args) {
int v[] = { 1, 3, 2 };
int x = 2;
int y = 2;
Polinomio obj = new Polinomio();
System.out.print("La funzione è: ");
obj.StampaFunzione(v);
System.out.print("Per x = " + x + " la funzione risulta --> ");
obj.Funz(v, x);
System.out.print("La derivata è: ");
obj.StampaDerivata(v);
System.out.println("");
System.out.print("Per x = " + y + " la derivata risulta --> ");
obj.Derivata(v, y);

}
}

la classe StampaFunzione e StampaDerivata non erano richieste e non avrei dovuto mettere tutti quei println, ma visto che sono a casa e lo posso provare con il pc volevo vedere se funzionava...

qualcuno mi spiega come avrei dovuto risolvere quest'esercizio con le classi derivate? :rolleyes:

[banryu79]

qualcuno mi spiega come avrei dovuto risolvere quest'esercizio con le classi derivate? :rolleyes:

Se ho capito bene, avresti dovuto prima implementare la classe Polinomio, con le funzionalità che ti erano state richieste tranne la capacità di calcolare la derivata in corrispondenza di un valore.

A quel punto poi, avresti dovuto implementare una classe Polinomio2, che estende (deriva/eredita da) Polinomio, nella quale ti sarebbe bastato aggiungere la funzionalità mancante.


// file Polinomio.java
public class Polinomio
{
// implementazione della classe Polinomio
}


...


// file Polinomio2.java
public class Polinomio2 extends Polinomio
{
// definizione del metodo che calcola la derivata
// per un valore in input
}

[Xfree]

Segui il suggerimento di banryu79 e vedi se riesci a farlo, eventualmente confrontiamo la soluzione, ho modificato un pò il tuo codice. ;)

[Balop]

allora, ho fatto la classe polinomio2 e ho scritto questo:
public class Polinomio2 extends Polinomio {
public void Derivata(int v[], int x) {
int ris = v[1];
for (int i = 2; i < v.length; i++) {
int n = v[i] * i * x;
ris = ris + n;
x = x * x;
}
System.out.println(ris);
}

public static void main(String[] args) {
int v[] = { 1, 3, 2 };
int x = 2;
Polinomio2 obj = new Polinomio2();
System.out.print("Per x = " + x + " la derivata risulta --> ");
obj.Derivata(v, x);
}

}

per funzionare funziona, però volevo sapere se si poteva fare in altro modo...
inoltre nella classe polinomio2 ho dovuto dichiarare nuovamente il vettore che non eredita dalla classe polinomio,
la stessa cosa mi era capitata con un altro esercizio, non si può evitare giusto?
anche se in verità nei compiti il prof non vuole scritto nè il main nè i vari println, quindi non ci sarebbe questo problema...

[Xfree]

Il main potresti cominciare a scriverlo in un altro file sorgente ancora. Ma costruttore non ne dichiari?
Questa è la mia soluzione:

Classe Polinomio

public class Polinomio {
int v[];

public Polinomio(int []v) {
this.v = new int [v.length];
System.arraycopy(v,0,this.v,0,v.length);
}


public void stampaFunzione() {
for (int i = getNumeroCoefficienti() - 1; i >= 0; i--) {
if (i > 1 && v[i] != 0) {
if (v[i] > 1)
System.out.print(v[i] + "x^" + i);
else
System.out.print("x^" + i);
}
if (i == 1 && v[i] != 0) {
if (v[i] > 1)
System.out.print(v[i] + "x");
else
System.out.print("x");
}
if (i == 0 && v[i] != 0)
System.out.println(+v[i]);
if (i >= 1 && v[i - 1] != 0)
System.out.print(" + ");
}
}

public void valorePolinomio(int x) {
int ris = v[0];
for (int i = 1; i < getNumeroCoefficienti() ; i++) {
int n = v[i] * x;
ris = ris + n;
x = x * x;
}
System.out.println(ris);
}

public int getNumeroCoefficienti() {
return this.v.length;
}
}


Classe Polinomio2

public class Polinomio2 extends Polinomio {

public Polinomio2(int v[]) {
super(v);
}

public void calcolaDerivata() {
int []temp = new int[getNumeroCoefficienti()-1];
for (int i = getNumeroCoefficienti()-1; i > 0; i--)
temp[i-1] = v[i]*i;
v = temp;

}
}


Classe TestPolinomio

public class TestPolinomio {
public static void main(String[] args) {
int v[] = { 1, 3, 2 };
int x = 2;
Polinomio obj = new Polinomio(v);
System.out.print("La funzione e': ");
obj.stampaFunzione();
System.out.print("Per x = " + x + " la funzione risulta --> ");
obj.valorePolinomio(x);
Polinomio2 obj2 = new Polinomio2(v);
System.out.print("La derivata e': ");
obj2.calcolaDerivata();
obj2.stampaFunzione();
System.out.print("Per x = " + x + " la derivata risulta --> ");
obj2.valorePolinomio(x);
}
}

[Balop]

a che serve questo??

System.arraycopy(v,0,this.v,0,v.length);


per il resto il programma è "simile" al mio, cambia solo che tu hai usato getNumeroCoefficienti(), hai calcolato la derivata in un altro modo
e inoltre hai dichiarato il vettore all'inizio e poi lo hai inizializzato con this.v...... ma fa niente se mi dimentico di inizializzarlo?
per esempio con questo programma non ho ottenuto nessun errore.. strano. :confused:

comunque per il resto, sommariamente il mio non è pure giusto? :rolleyes:

[Oceans11]

a che serve questo??

System.arraycopy(v,0,this.v,0,v.length);



dalla documentazione java della sun:

System.arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
"Copies an array from the specified source array, beginning at the specified position, to the specified position of the destination array."


hai dichiarato il vettore all'inizio e poi lo hai inizializzato con this.v...... ma fa niente se mi dimentico di inizializzarlo?

fa, fa! :O
Se dimentichi di "inizializzarlo" (che poi non è un termine corretto) sei costretto a passare sto benedetto array v ad ogni metodo.
In quel modo invece usi la copia propria dell'istanza dell'oggetto Polinomio.

[Xfree]

Togliendo i cambiamenti "cosmetici" c'è che io ho definito un costruttore per ogni classe, ed il motivo è quello spiegato da Oceans11.
Come mai tu non hai usato costruttori?
Diciamo che non è un buon modo passare parametri tra oggetti quando questi parametri potrebbero essere attributi della classe.

[Balop]

eh si, avete ragione, alla fine l'ho fatta con il costruttore..
eccovi come le ho fatte:

classe polinomio
public class Polinomio {
int v[];
Polinomio(int []vett){
v=vett;
}
public void StampaFunzione(int v[]) {
for (int i = v.length - 1; i >= 0; i--) {
if (i > 1 && v[i] != 0) {
if (v[i] > 1)
System.out.print(v[i] + "x^" + i);
else
System.out.print("x^" + i);
}
if (i == 1 && v[i] != 0) {
if (v[i] > 1)
System.out.print(v[i] + "x");
else
System.out.print("x");
}
if (i == 0 && v[i] != 0)
System.out.println(+v[i]);
if (i >= 1 && v[i - 1] != 0)
System.out.print(" + ");
}
}

public void Funz(int v[], int x) {
int ris = v[0];
for (int i = 1; i < v.length; i++) {
int n = v[i] * x;
ris = ris + n;
x = x * x;
}
System.out.println(ris);
}
}

classe Polinomio2
public class Polinomio2 extends Polinomio {
Polinomio2(int[] vett) {
super(vett);
}

public void Derivata(int v[], int x) {
int ris = v[1];
for (int i = 2; i < v.length; i++) {
int n = v[i] * i * x;
ris = ris + n;
x = x * x;
}
System.out.println(ris);
}

public void StampaDerivata(int v[]) {
for (int i = v.length - 1; i > 0; i--) {
if (i > 2 && v[i] != 0)
System.out.print((v[i] * i) + "x^" + (i - 1));
if (i == 2 && v[i] != 0)
System.out.print((v[i] * i) + "x");
if (i == 1 && v[i] != 0)
System.out.print(v[i]);
if (i > 1 && v[i - 1] != 0)
System.out.print(" + ");
}
}

public static void main(String[] args) {
int v[] = { 1, 3, 2 };
int x = 2;
int y = 2;
Polinomio2 obj = new Polinomio2(v);
System.out.print("La funzione è: ");
obj.StampaFunzione(v);
System.out.print("Per x = " + x + " la funzione risulta --> ");
obj.Funz(v, x);
System.out.print("La derivata è: ");
obj.StampaDerivata(v);
System.out.println("");
System.out.print("Per x = " + y + " la derivata risulta --> ");
obj.Derivata(v, y);
}
}

questa volta dovrebbero essere corrette no?

[sottovento]

Beh, veramente c'e' ancora qualcosa che non va: hai dichiarato un vettore membro di nome v[] e lo inizializzi correttamente nel costruttore.
Ma poi non lo usi mai, perche' ad ogni metodo passi un vettore v[], che si suppone essere diverso (infatti va a "nascondere" il vettore membro).

Dovresti quindi cancellare dalla lista dei parametri formali delle funzioni il vettore v. Per intenderci, il metodo


public void StampaFunzione(int v[])

deve diventare

public void StampaFunzione()


Un'altra cosa: dichiarare


public class Polinomio {
int v[];

significa rendere "visibile" il vettore v a tutte le classi del package. Siccome e' un po' troppo, sarebbe opportuno fare in modo che altre classi non possano accedere a v. Dichiaralo protected.

[Balop]

Un'altra cosa: dichiarare


public class Polinomio {
int v[];

significa rendere "visibile" il vettore v a tutte le classi del package. Siccome e' un po' troppo, sarebbe opportuno fare in modo che altre classi non possano accedere a v. Dichiaralo protected.
vabbè dai, il prof non si attacca pure a certe cose, devo fare "solo" un compito mica devo fare un programma serio... :p

comunque grazie a tutti dei consigli!!!


Ps: ho pure un altro esercizio da proporvi, è senza classi ereditate ma mi funziona solo parzialmente..... :stordita: