Interface > Abstract > Class

[testy]

Hallo Zusammen,

ich habe mich soeben in diesem Forum angemeldet. Ich bin Programmierer und (hauptsächlich .Net) und muss hin und wieder Java SE/EE coden.

Ich suche eine Lösung (sicher nur eine Syntaxfrage) für folgendes Vererbungsproblem.

public interface CarProperty{
}

public interface Car{
   CarProperty getProperty();
   void setProperty( CarProperty value );
}

public abstract class AbstractCar<TProperty extends CarProperty> implements Car {
   public CarProperty getProperty();    //this is ok
   public void setProperty( TProperty value );  //this is not ok

}

Welche Syntax muss ich anwenden um die setProperty mit generics als auch die setProperty des interfaces Car zu bedienen?

Gruß,
testy

 

[Tomate_Salat]

du könntest es so lösen:

public interface CarProperty {
}

public interface Car<T extends CarProperty> {
	T getProperty();
	void setProperty(T value);
}

public abstract class AbstractCar<T extends CarProperty> implements Car<T>
{
	@Override
	public void setProperty(T value) {
		
	}
}

 

[testy]

wow, das ging schnell.
Ja, das ist eine Lösung. Jedoch möchte ich die die Car-Klassen so verwenden.

public class FastCarProperty implements CarProperty{
}

public class FastCar extends AbtractCar<FastCarProperty>{ 
  ...
}

CarProperty x = myFastCarPropertyInstance;

//Fall 1:
Car interfaceCar = myFastCar;
interfaceCar.setProperty( x );

//Fall 2:
AbstractCar absCar = (AbstractCar<FastCarProperty>)myFastCar;
absCar.setProperty( (FastCarProperty)x );

//usw.

Wichtig ist, dass Fall 1 ohne die Angabe von generics funktioniert. Von der Vererbung her sollte also folgender Aufbau möglich sein:

Interface > GenericInterface > AbstractClass > Class

wobei jede auf der/dem vorhergehenden Klasse/Interface aufbaut.

 

[Marco13]

Das heißt dass jedes Car (auch jedes Spezielle, z.B. FastCar) mit dem Allgemeineren Interface zurechtkommen muss? Das wäre dann

public abstract class AbstractCar /*<TProperty extends CarProperty>*/ implements Car {
   public CarProperty getProperty();    //this is ok
   /*public void setProperty( TProperty value );  //this is not ok*/
}

Aber vermutlich nicht das, was du willst!?

 

[testy]

Genau, außer, dass ich mit meinen KOmmentaren etwas uneindeutig war.

"this is not ok" bedeutet, der Compiler will es nicht
"this is ok" bedeutet, der Compiler nimmt es an

das heißt:
- im Interface muss es

setProperty( CarProperty value )

geben
- im darauf aufbauenden generischen Interface/Abstract Class muss es

setProperty( TProperty value )

geben
- in der darauf aufbauenden speziellen Klasse muss es

setProperty( FastCarProperty value )

geben

Vielleicht ist dies ja auch gar nicht möglich. In .Net geht sowas. Vielleicht als Beispiel wie die Klasse in C# aussehen würde:

public interface Car{
   CarProperty getProperty();
   void setProperty( CarProperty value );
}

public abstract class Car<TProperty> where TProperty:CarProperty{
   TProperty getProperty();
   void setProperty( TProperty value );
}

public class FastCar : Car<FastCarProperty>, Car {

    CarProperty Car.getProperty(){...}
    void Car.setProperty( CarProperty value ) {...}

    public FastCarProperty getProperty(){...}
    public void setProperty(FastCarProperty value){...}

}

Der Unterschied ist, dass ich den Member vom einfachen Interface Car "ausblenden" kann. Würde ich die FastCarKlasse explizit nach Car casten würde ich dann die "ausgeblendete" Property nutzen.

 

[Tomate_Salat]

Halte ich für einen Designfehler. Denn dann könntest du mit einem cast auf Car jede beliebige Property zuweisen. Mit meiner Methode hättest du wenigstens noch einen lesenden Zugriff. Was vllt ausreichen könnte:

Car<?> myCar = new FastCar();
CarProperty prop = myCar.getProperty();
// ... do something with prop
if(myCar instanceof FastCar) {
	FastCar myFastCar = (FastCar) myCar;
	// ... do something with myFastCar
}

edit Ach ja und btw:
Java™ Quelltext ist bitte in [ JAVA]-Tags zu schreiben: [ JAVA]hier Java Code einfügen[ /JAVA]

 

[testy]

Tomate_Salat: meine Mitteilungen hatte ich vor Deinem Post bereits entsprechend formatiert (JAVA). Mein zuvor erstellter Beitrag zeigt keinen JavaCode sondern C# - deshalb auch nicht JavaCode.

Eine beliebige Property kann ich NICHT zuweisen, denn es wird immer die nach außen sichtbare Variante genommen. Weiterhin ist das in .Net möglich. Und als Design-Fehler würde ich es nicht gleich bezeichnen.

Nichts desto trotz nehm ich einfach Deinen letzten Vorschlag (auf das mit dem

Car<?>

war ich nicht gekommen). Der ist am nächsten an der Lösung und mit dem kann ich auch erstmal gut leben. Ich vermute auch inzwischen, dass das was ich möchte bei Java nicht geht. Mir fehlt leider der Fachbegriff für dieses Ableitungskonstrukt. Hat jemand eine Idee?

Ich danke euch für all die Vorschläge! Das ging vor allem ziemlich fix, super!

 

[Marco13]

Ein paar Stichworte wären Kovarianz und Kontravarianz ? Wikipedia

 

[Tomate_Salat]

@testy: hab deinen vorherigen Beitrag nicht im Kopf, aber kann sein, dass dein Beitrag einfach länger auf war und ich die Änderung nicht mitbekommen habe, letztendlich auch egal, ich denke es geht um eine Java-Lösung ;-). Ich weis nicht wie das in .NET ausschaut (werde ich aber mal testen^^)

 

[Landei]

Normalerweise hat man sowas:

public interface CarProperty {
}

class TProperty implements CarProperty {
}
 
public interface Car<T extends CarProperty> {
    T getProperty();
    void setProperty(T value);
}

public abstract class AbstractCar implements Car<TProperty>
{
    @Override
    public void setProperty(TProperty value) {
        
    }
}

 

[testy]

Landei: das ist ein schöner Trick, den Generic TProperty einfach als Klasse zu definieren ... es ist auch schwierig zu erklären was ich will. Unten ist der Code, wie ich ihn hätte gern gehabt.

Tomate_Salat: Zur Vollständigkeit fürs ausprobieren der C# Code

    class Program {
        static void Main( string[] args ) {

            FastCar fastCar = new FastCar();
            Car iCar = fastCar;

            FastCarProperty fastCarProp1 = fastCar.getProperty();
            CarProperty fastCarProp2 = fastCar.getProperty();

            CarProperty carProp1 = iCar.getProperty();
            iCar.setProperty( fastCarProp1 );


        }
    }

    
    public class CarProperty {}

    

    public interface Car {

        CarProperty getProperty();
        void setProperty( CarProperty value );

    }

    public interface Car<TProperty> where TProperty : CarProperty {
        TProperty getProperty();
        void setProperty( TProperty value );
    }

    public abstract class AbstractCar<TProperty> : Car<TProperty>, Car
        where TProperty : CarProperty {

        TProperty _property;

        #region Car implementation
        
        CarProperty Car.getProperty() { return _property; }
        void Car.setProperty( CarProperty value ) { _property=(TProperty)value; }

        #endregion


        #region Car<> implementation
        
        public TProperty getProperty() { return _property; }
        public void setProperty( TProperty value ) { _property=value; }

        #endregion

    }

    public class FastCarProperty : CarProperty { }
    public class FastCar : AbstractCar<FastCarProperty> {}

Also der springende Punkt ist, dass ich das Interface benutzen möchte, ohne Car<?> anzugeben. Aber inzwischen nehme ich erstmal Car<?>.

 

[Tomate_Salat]

Könnte so deine Lösung ausschauen (unter Verwendung von Landei's vorschlag):

public class Demo
{
	public static void main(String[] args)
	{
		AbstractCar car = new FastCar(); // oder Car<TProperty> car = new FastCar();
		car.setProperty(new FastCarProperty());
	}
}

public interface CarProperty {}
public class TProperty implements CarProperty {}

public interface Car<T extends CarProperty> {
	T getProperty();
	void setProperty(T value);
}

public abstract class AbstractCar implements Car<TProperty>
{
	@Override
	public void setProperty(TProperty value) {
		
	}
	
	@Override
	public TProperty getProperty() {
		return null;
	}
}

public class FastCar extends AbstractCar {}
public class FastCarProperty extends TProperty {}