(Risolto) [Java] Programmazione Object Oriented, aiutatemi a trovare l'errore

[AR89]

Ho creato un programma che fa operazioni di Algebra Lineare.

La classe crea dei vettori che hanno le seguenti caratteristiche:

coordinata x,

coordinata y,

coordinata z,

modulo del vettore.

il compilatore mi dà i seguenti errori:

missing return statement
}//prodottoVettoriale
^
missing return statement
}//add
^
missing return statement
}//sub
^
3 errors

i tre metodi che riportano l'errore sono metodi che devono costruire un vettore partendo da due vettori, (eseguono il prodotto vettoriale, la somma e la differenza fra vettori).

Non capisco cosa dovrei restituire (return) con un medoto che costruisce oggetti.

import java.util.*;

public class Vettore {
private double x;
private double y;
private double z;
private double modulo;

public Vettore (double x, double y, double z) {
	this.x=x;
	this.y=y;
	this.z=z;
	modulo= Math.sqrt((x*x)+(y*y)+(z*z));
}// costruttore normale
public Vettore (Vettore v) {
	this.x=v.x;
	this.y=v.y;
	this.z=v.z;
	this.modulo=v.modulo;
}//costruttore di copia
public double getX() {
	return x;
}//getX
public double getY(){
	return y;
}//getY
public double getZ(){
	return z;
}//getZ
public double getModulo(){
	return modulo;
}//getModulo
public double prodottoScalare(Vettore v){
	double prodottoScalare= (x*v.x)+(y*v.y)+(z*v.z);
	return prodottoScalare;
}//prodottoScalare
public static double angolo (double prodottoScalare){
	double angolo= Math.acos(prodottoScalare);
	return angolo;
}//angolo
public Vettore prodottoVettoriale(Vettore v){
	x= (this.y*v.z)-(v.y*this.z);
	y= -(this.x*v.z)-(v.x*this.z);
	z= (this.x*v.y)-(v.x*this.y);
	modulo= Math.sqrt((x*x)+(y*y)+(z*z));
}//prodottoVettoriale
public boolean ortogonale(Vettore v){
	if ((x*v.x)+(y*v.y)+(z*v.z)==0) {
		return true;
	}
	return false;
}//ortogonale
public boolean parallelo(Vettore v){
	double x= (this.y*v.z)-(v.y*this.z);
	double y= -(this.x*v.z)-(v.x*this.z);
	double z= (this.x*v.y)-(v.x*this.y);
	if (x==0 && y==0 && z==0) {
		return false;
	}
	return true;
}//parallelo
public boolean nullo(){
	if (this.x==0 && this.y==0 && this.z==0){
		return true;
	}
	return false;
}//nullo
public Vettore add(Vettore v){
	x= this.x+v.x;
	y=this.y+v.y;
	z=this.z+v.z;
	modulo= Math.sqrt((x*x)+(y*y)+(z*z));
}//add
public Vettore sub(Vettore v){
	x=this.x-v.x;
	y=this.y-v.y;
	z=this.z-v.z;
	modulo=Math.sqrt((x*x)+(y*y)+(z*z));
}//sub

public String toString(){
	return "Il vettore di coordinate x= "+String.format("%1.2f", this.x)+"y= "+String.format("%1.2f", this.y)+"z= "+String.format("%1.2f", this.z)+" ha modulo= "+String.format("%1.2f", this.modulo);
}//toString

[applefanMac]

Premetto che sono un novellino, ma leggendo il testo dle programma mi sembra che tu alla fine dei tre metodi indicati dal compilatore dimentichi di scrivere la variabile che viene ritornata quando viene chiamato il metodo.

I metodi non sono void, quindi devono ritornare una variabile.

Prova così e vedi se va;)

PS: se per miracolo il mio aiuto funziona, dato che mi sembri molto più esperto di me prova a dare un'occhiata nell'altro topic che ho aperto in questa sezione e vedi se riesci a trovare perchè il mio programma non funziona:oops:

[iTia]

Nelle classi

public Vettore add(Vettore v){

public Vettore sub(Vettore v){

e anche in prodotto vettoriale mancano le return delle funzioni...

:lol:

[AR89]

I metodi costruiscono oggetti (ti tipo "Vettore"), quindi non devono ritornare nulla!

Forse ancora non conoscete la Programmazione orientata agli oggetti;), guardate i primi due metodi, anche quelli non sono void e non restituiscono nulla! In realtà quelli sono metodi costruttori, esattamente come i metodi che mi danno l'errore.

Edit: Lorenzo90, appena posso vado a darci un'occhiata, l'avevo già visto ma non so di preciso cosa non funziona.

[pierinocontrotutti]

I metodi costruiscono oggetti (ti tipo "Vettore"), quindi non devono ritornare nulla!

Forse ancora non conoscete la Programmazione orientata agli oggetti;), guardate i primi due metodi, anche quelli non sono void e non restituiscono nulla! In realtà quelli sono metodi costruttori, esattamente come i metodi che mi danno l'errore.

Edit: Lorenzo90, appena posso vado a darci un'occhiata, l'avevo già visto ma non so di preciso cosa non funziona.

Secondo me è sbagliata la concezione del metodo, mi spiego:

se il metodo add deve aggiungere solo dei valori ai valori x, y e z del vettore che gli passi, a questo punto non deve costruire un altro vettore, ma bensì deve fare un'operazione sul vettore stesso che gli passi, quindi il tipo di ritorno deve essere void. Diversamente, se il metodo add crea un altro vettore a partire da quello che gli passi, allora devi mettere il return...

ho reso l'idea?

[AR89]

Secondo me è sbagliata la concezione del metodo, mi spiego:

se il metodo add deve aggiungere solo dei valori ai valori x, y e z del vettore che gli passi, a questo punto non deve costruire un altro vettore, ma bensì deve fare un'operazione sul vettore stesso che gli passi, quindi il tipo di ritorno deve essere void. Diversamente, se il metodo add crea un altro vettore a partire da quello che gli passi, allora devi mettere il return...

ho reso l'idea?

Sì, mettendo void il metodo funziona, tuttavia se invece di void volessi che il metodo restituisse un oggetto di tipo "Vettore" (invece di modificare uno dei due), cosa dovrei fare?

Edit: mi sono riposto da solo (e soprattutto grazie a pierino;))

Ecco come ho modificato il codice, se si và provatelo anche voi:fiorellino:

import java.util.*;

public class Vettore {
private int x;
private int y;
private int z;
private double modulo;

public Vettore (int x, int y, int z) {
	this.x=x;
	this.y=y;
	this.z=z;
	modulo= Math.sqrt((x*x)+(y*y)+(z*z));
}// costruttore normale
public Vettore (Vettore v) {
	this.x=v.x;
	this.y=v.y;
	this.z=v.z;
	this.modulo=v.modulo;
}//costruttore di copia
public int getX() {
	return x;
}//getX
public int getY(){
	return y;
}//getY
public int getZ(){
	return z;
}//getZ
public double getModulo(){
	return modulo;
}//getModulo
public double prodottoScalare(Vettore v){
	double prodottoScalare= (x*v.x)+(y*v.y)+(z*v.z);
	return prodottoScalare;
}//prodottoScalare
public static double angolo (double prodottoScalare){
	double angolo= Math.acos(prodottoScalare);
	return angolo;
}//angolo
public Vettore prodottoVettoriale(Vettore v){
	Vettore w= new Vettore (0,0,0);
	w.x= (this.y*v.z)-(v.y*this.z);
	w.y= -(this.x*v.z)-(v.x*this.z);
	w.z= (this.x*v.y)-(v.x*this.y);
	w.modulo= Math.sqrt((w.x*w.x)+(w.y*w.y)+(w.z*w.z));
	return w;
}//prodottoVettoriale
public boolean ortogonale(Vettore v){
	if ((x*v.x)+(y*v.y)+(z*v.z)==0) {
		return true;
	}
	return false;
}//ortogonale
public boolean parallelo(Vettore v){
	int x= (this.y*v.z)-(v.y*this.z);
	int y= -(this.x*v.z)-(v.x*this.z);
	int z= (this.x*v.y)-(v.x*this.y);
	if (x==0 && y==0 && z==0) {
		return false;
	}
	return true;
}//parallelo
public boolean nullo(){
	if (this.x==0 && this.y==0 && this.z==0){
		return true;
	}
	return false;
}//nullo
public Vettore add(Vettore v){
	Vettore w= new Vettore (0,0,0);
	w.x= this.x+v.x;
	w.y=this.y+v.y;
	w.z=this.z+v.z;
	w.modulo= Math.sqrt((x*x)+(y*y)+(z*z));
	return w;
}//add
public Vettore sub(Vettore v){
	Vettore w= new Vettore (0,0,0);
	w.x=this.x-v.x;
	w.y=this.y-v.y;
	w.z=this.z-v.z;
	w.modulo=Math.sqrt((x*x)+(y*y)+(z*z));
	return w;
}//sub
public static boolean verificaBase (Vettore v1, Vettore v2, Vettore v3){
	double determinante= v1.x*((v2.y*v3.z)-(v2.z*v3.y))-v2.x*((v1.y*v3.z)-(v1.z*v3.y))+v3.x*((v1.y*v2.z)-(v1.z*v2.y));
	if (determinante==0) return false;
	return true;
}//verifica Base
/*public boolean equals (Object o){
	if (Vettore.prodottoVettoriale(Object o)==0) return true;
	return false;
}//equals*/
public String toString(){
	return "Il vettore di coordinate\nx= "+this.x+"\ny= "+this.y+"\nz= "+this.z+"\nha modulo= "+String.format ("%1.2f",this.modulo);
}//toString
public static void main(String[] args) {
	Vettore v= new Vettore (1,3,-2);
	Vettore t= new Vettore (4, -2, -1);
	System.out.println(v);
	double prodottoScalare= v.prodottoScalare(t);
	double angolo= angolo(prodottoScalare);
	Vettore w=v.prodottoVettoriale(t);
	System.out.println("Il prodotto scalare è: "+prodottoScalare+" l'angolo compreso è: "+angolo);
	System.out.println(w);
	System.out.println("I due vettori sono ortogonali?"+v.ortogonale(t));
	Vettore v1= new Vettore (1,2,3);
	Vettore v2= new Vettore (2,4,6);
	Vettore v3= new Vettore (0,0,0);
	System.out.println(verificaBase(v1, v2, v3));
}//main
}

[pierinocontrotutti]

Mi fà piacere che hai risolto..

Da come leggo il codice quindi i tuoi metodi fanno quelle operazioni su x, y e z di un vettore e poi i valori li mettono in x, y e z di un altro vettore...

P.S.: all'inizio pensavo di non ricordarmi niente niente di Java...e invece!!!

[AR89]

Mi fà piacere che hai risolto..

Da come leggo il codice quindi i tuoi metodi fanno quelle operazioni su x, y e z di un vettore e poi i valori li mettono in x, y e z di un altro vettore...

P.S.: all'inizio pensavo di non ricordarmi niente niente di Java...e invece!!!

Sì, prendono i valori x, y, z di due vettori (guarda come li ho implementati nel main) e attraverso quelle formule ne creano un altro (che nei metodi ho chiamato w).

Ho fatto un pò di confusione a causa dei primi due metodi che non devono restituire nulla.

[pierinocontrotutti]

Ci sono andato vicino!! Col main è più chiaro, nel riquadro del primo post non c'era...