casten von Interface zu Klasse unterbinden

[stev.glasow]

Hi,
folgender Code:

public interface Point {
    public float getX();
    public float getY();
}

///////////////////////

public class PointImpl implements Point{
    
    
    private float x,y;
    
    public float getX(){
        return x;
    }
    public float getY(){
        return y;
    }
    
    public void setX(float val){
        x = val;
    }
    public void setY(float val){
        x = val;
    }
}

///////////////////////

public class Test{
	public static void main(String[] args){
		Point p =  ppp();
	    PointImpl pl = (PointImpl)p;
	    pl.setX(5);
	    System.out.println(p.getX());
	
	}
	
	static Point ppp(){
	    return new PointImpl();
	}
}

Ausgabe ist 5.

Wie kann ich es unterbinden, dass man Point p zu PointImpl casten kann, sprich das man nicht mehr die setX() aufrufen kann. Ich wollte mit dem Interface eigentlich erzwingen das man damit die Koordinaten nur lesen kann.
Wer KANN helfen?

PS: zum Thema kann-Wiederholung:
[schild=2 fontcolor=000000 shadowcolor=C0C0C0 shieldshadow=1] es ist 2:53 Uhr[/schild]

nacht.

 

[bygones]

geht nicht (sag ich einfach mal)...

sobald einem böswilligen Programmiere die Impl Klasse bekannt ist kann er casten was er will...

du kannst nur so viel machen, dass du nur die Interface Definition bekannt gibts - möglichkeit wäre die Impl als private Klasse zu definieren... könnte gehen (oder ?)

mann ist das spät

 

[bygones]

also, es geht so....

ein bsp:

public class PointTest {
  public static void main(String[] args) {
      Point p = PointFactory.getPoint();
  }
}

public interface Point() {
  // ....
}

public class PointFactory() {
  public static Point getPoint() {
     return new PointImpl();
  }


  private static class PointImpl implements Point {
    // ...
  }
}

[/code]

 

[Bleiglanz]

ginge doch auch mit einer anonymen inneren Klasse, die man in der Factory-Methode

PointFactory.getPoint();

zurückliefert?

 

[bygones]

klar - es gibt immer mehrere Möglichkeiten ein problem zu lösen

 

[stev.glasow]

Soweit war mir das auch klar nur sollten Point und PointImpl public sein. Die PointImpl soll auch von anderern Klassen benutzt werde ohne diese jedes mal neu zuschreiben. Ich werds wohl so lösen:

public class PointImpl implements Point{
    
    private final Point p = new Point(){
        public float getX(){
            return x;
        }
        public float getY(){
            return y;
        }
    };
    private float x,y;
    
    public float getX(){
        return x;
    }
    public float getY(){
        return y;
    }
    
    public void setX(float val){
        x = val;
    }
    public void setY(float val){
        x = val;
    }
    
    public Point readOnly(){
        return p;
    }
    
    
}

Wenn noch jemand ne bessere Lösung weiß, immer raus damit.

 

[bygones]

sobald die Impl public ist kann jeder wie er Lust hat das ganze wieder zurückcasten - daher wäre das dann unnütz

möglichkeit wäre das Read-Only Pattern: http://www.java-forum.org/de/viewtopic.php?t=6090#28851

ansonsten stellt sich die Frage warum dann das Interface bzw. warum das Interface nicht auch die set Methoden definiert !

 

[stev.glasow]

Ne, das Read-Only Pattern hilft auch nicht, die Einschränkung, dass nur Klassen aus dem gleichen Package "Schreibrechte" haben gefällt mir nicht.
Ich glaub ich muss das nochmal umdenken, aber nicht mehr heute. *KnallerbsenRauskram* Notfalls bleibe ich bei der vorher genannten Lösung.

 

[Roar]

kannst du PointImpl nicht default machen?

 

[stev.glasow]

Ich habe es jetzt mir eine inneren öffentlichen Klasse 'LowAccess' gelöst:

public class Point2D extends java.awt.geom.Point2D.Float{
    
    
    private final LinkedList<PositionListener> listeners = new LinkedList<PositionListener>();
    
    public Point2D(){
        super();
    }
    public Point2D(float x, float y){
        super(x, y);
    }
    
    public void setLocation(double x, double y){
        this.setLocation((float)x, (float)y);
    }
    
    public void setLocation(final float x, final float y){
        super.setLocation(x, y);
        final Iterator<PositionListener> i = listeners.iterator();
        while(i.hasNext()){
            i.next().positionHasChanged(x, y);
        }
    }
    
    public void addListener(PositionListener listener){
        listeners.add(listener);
    }
    public void removeListener(PositionListener listener){
        listeners.remove(listener);
    }
    
    public class LowAccess{
        public float getX(){ return x;}
        public float getY(){ return y;}
    }
    
}

Ist zwar nicht mehr der gleiche Code wie oben, aber das Problem ist (war) das gleiche. Das Iterface wird somit auch nicht mehr benötigt. Gibt's Meinungen?

 

[Roar]

wieso machst du LowAccess denn public?

 

[stev.glasow]

[edit]
achso hab "wo" gelesen, wieso denn nicht? Wenn ich sie private machen bringt mir das ja irgendwie nix. Oder was meinst du?

 

[stev.glasow]

Hier mal Beispiel in der Nutzung vielleicht wird dann auch mein Problem etwas klarer:

public class MoveableObject{
    private final Point2D myPosition = new Point2D();
    
    ...
    
    /* hier kann sich jemand meine Position holen
     * aber er soll diese nicht ändern dürfen
     */
    public Point2D.LowAccess getMyPosition(){  
    	return myPosition.new LowAccess();
    }
    
    ...
   
}

 

[Roar]

*grübel* willst du jetzt deine interfaceimplementierung vorm user verstecken oder willst du deine interfacei mplemention read-only machen?

 

[stev.glasow]

ready-only machen.
Man könnte auch die von 31. 12. 2004, 14:24 aber gefallen tut mir das alles irgendwie nicht. Deswegen wollte ich euch ja mal fragen

 

[stev.glasow]

Hat sich erledigt, ich mach'S jetzt ganz anderes :roll: