Java unterschied zwischen Interface und Interface_Referenzen!!??

[ohmp2007]

Hallo Leute,

kann mir einer anhand meinen zwei Codings erklären wo der unterschied zwischen Interface und Interface_Referenzen liegt?

Ich weiß z.B. dass IF_Ref nur Objekte Referenzieren kann...

Interface

public interface IF_Vector {
	double skalarprodukt (double [] vec1, double [] vec2);
	double [] kreuzprodukt (double [] vec1, double [] vec2);

}

public class Berechne implements IF_Vector {
	
	public double skalarprodukt (double [] vec1, double [] vec2){
		double erg = 0;

		for (int i=0; i<vec1.length; i++){
			erg = vec1[i] * vec2[i] + erg;
		}
		return erg;
	}
	
	public double [] kreuzprodukt (double [] vec1, double [] vec2){
		
		double[] erg = new double [3]; 
		
		erg[0] = vec1[1] * vec2[2] - vec1[2] * vec2[1];
		erg[1] = vec1[2] * vec2[0] - vec1[0] * vec2[2];
		erg[2] = vec1[0] * vec2[1] - vec1[1] * vec2[0];
		
		for (int i=0; i<erg.length; i++){
			
			System.out.println(erg[i]);	
		}
		
		return erg;
	}
	
	public static void main(String args[]){
		
		double [] vec1 = {1.0, 0.0, 3.2};
		double [] vec2 = {2.1, 1.4, 1.9};
		
		Berechne B1 = new Berechne();
		
		double erg = B1.skalarprodukt(vec1, vec2);
		System.out.println(erg);
		
		double [] ergebnis = B1.kreuzprodukt(vec1, vec2);
		System.out.println(ergebnis);
	}

}

Interface mit Referenzen

public interface IF_Vector {
	double skalarprodukt (IF_Vector b);
	double [] kreuzprodukt (IF_Vector b);
	double [] getComponents();
}

public class Berechne implements IF_Vector {
	
	double [] vec1 = new double [3];

	public Berechne (double[] neuervec){
		this.vec1=neuervec;
	}
	
	public double [] getComponents(){
		return vec1;
	}
	
	
	public double skalarprodukt (IF_Vector b){
		
		double [] vec2 = b.getComponents();
		double erg = 0;

		for (int i=0; i<vec1.length; i++){
			erg = vec1[i] * vec2[i] + erg;
		}
		return erg;
		
	}
	
	public double [] kreuzprodukt (IF_Vector b){
		
		double [] vec2 = b.getComponents();
		double [] erg = new double [3]; //Rückgabewert
		
		erg[0] = vec1[1] * vec2[2] - vec1[2] * vec2[1];
		erg[1] = vec1[2] * vec2[0] - vec1[0] * vec2[2];
		erg[2] = vec1[0] * vec2[1] - vec1[1] * vec2[0];
			
			return erg;
	}
	
	public static void main(String [] args){
		
		double [] a = {1.0, 0.0, 3.2};
		double [] b = {2.1, 1.4, 1.9};
		
		IF_Vector vec1 = new Berechne(a);
		IF_Vector vec2 = new Berechne(b);
		
		//vec1 ist die Referenz Variable, die ist vom Typ IF_Vector und das Objekt was erzeugt       wurde ist vom Typ Berechne!  <-- stimmt das???????
		
		double skalar = vec1.skalarprodukt(vec2);
		System.out.println("Skalarprodukt: "+skalar);
		
		double [] kreuz = vec1.kreuzprodukt(vec2);
		for (int i=0; i<kreuz.length; i++){
			
			System.out.println("Kreuzprodukt: "+kreuz[i]);	
		}
	}
}

Bei den Interface_Referenzen brauche ich doch einen Kontruktor oder? Über Verbesserungen und Vorschläge bin sehr dankbar!!!

 

[Marcinek]

Ich sehe keinen technischen Unterschied zwischen den Interfaces.

Interfaces geben Methoden Signaturen vor und keine Konstruktoren.

 

[Marco13]

Zur Frage im Code: Ja, das kann man so sagen.

Ansonsten wäre es gut, wenn du die Frage präzisieren könntest. Die beiden Möglichkeiten bieten sich in ähnlicher Form sehr oft. Dass da so viel mit Arrays rumhantiert wird, ist (bei GANZ abstrakt-objektorientierter Betrachtung) ein bißchen fragwürdig. Man müßte wissen, in welchem Zusammenhang das ganze steht...

 

[ohmp2007]

Meine erste zwei Coding Beispiel sind ganz normal über IF & meine letzten zwei Codings habe Interfacereferenzen als Parameter angegeben!

Ich wollte einfach mal nur den Zusammenhang zwischen Interface und Interfacereferenzen wissen? Braucht man bei Interfacereferenzen einen Konstruktor? So dass ich dann in der main drauf zugreifen kann?

IF_Vector vec1 = new Berechne(a);

 

[Noctarius]

Was verdammt sind Interfacereferenzen und wer hat dir dieses Wort beigebracht? Oo

 

[bERt0r]

Ich glaube er meint damit einfach Variablen (Eigenschaften) im Interface.
Dein Beispiel ist nicht wirklich anschaulich, eine Klasse würde ich nie "Berechne" nennen. Klassennamen sollten immer Hauptworte sein, Methoden sollten Verbe sein.
Du hast da glaube ich das OO Grundkonzept falsch verstanden.

 

[ohmp2007]

Könntest du mein Beispiel so verändern das es anschaulich wird? 🙂

 

[bERt0r]

Öhm

interface MyVector
{
double values[];
double skalarprodukt (MyVector vector2);
double [] kreuzprodukt (MyVector vector2);
double[] getValues();
}

class MyVector3D implements MyVector
{
Vector(double x, double y, double z)
{
values=new double[3];
values[0]=x;
values[1[=y;
values[2]=z;
}

public double[] getValues()
{
return values;
}

public double skalarprodukt (MyVector b){
        
        double [] vec2 = b.getValues();
        double erg = 0;
 
        for (int i=0; i<this.values.length; i++){
            erg = this.values[i] * vec2[i] + erg;
        }
        return erg;
    }

public double [] kreuzprodukt (MyVector b){
        
        double [] vec2 = b.getValues();
        double [] erg = new double [3]; //Rückgabewert
        
        erg[0] = vec1[1] * vec2[2] - vec1[2] * vec2[1];
        erg[1] = vec1[2] * vec2[0] - vec1[0] * vec2[2];
        erg[2] = vec1[0] * vec2[1] - vec1[1] * vec2[0];
            
            return erg;
    }

 public static void main(String [] args){
        
MyVector3D a=new MyVector3D(1.0,0.0,3.2);
MyVector3D b=new MyVector3D(2.1,1.4,1.9);
        
        
        double skalar = a.skalarprodukt(b);
        System.out.println("Skalarprodukt: "+skalar);
        
        double [] kreuz = a.kreuzprodukt(b);
        for (int i=0; i<kreuz.length; i++){
            System.out.println("Kreuzprodukt: "+kreuz[i]);  
        }
    }