Schnittstellen und Abstrakte Klassen

[conspectumortis]

Huhu mal wieder =)

wir haben mal wieder eine Verständnisaufgabe bekommen ,ich hab sie bisher, glaub ich zumindest, gelöst nur stehe ich vor der Frage wie und warum ich bei den konkreten Unterklassen der Abstrakten Klassen nochmal private Objektvariablen nutzen soll (lauf Aufgabe).

Aufgabenstellung wie folgt:
Die Abstrakten Klassen können Abstrakte Oberklassen besitzen und werden mitells Schnittstellen implementiert. Die Schnittstellen waren gegeben.
Nun sollen die restlichen Methoden die nicht in den Abstrakten Klassen definiert wurden in den konkreten Unterklassen der Abstrakten Klassen implementiert werden unter der Bedingung das diese konkreten Unterklassen einen öffentlichen Konstruktor und die besagte "privaten Objektvariablen" beinhalten sollen.

Konstruktoren hab ich erstellt,soweit waren auch keine Fehler und anstatt private Objektvariablen hab ich protected Variable bei:

abstract class AbstractParallelogram implements Parallelogram{
	
	protected double side2,side1;
	
	public AbstractParallelogram(double side1,double side2){
		this.side1=side1;
		this.side2=side2;
	}

Hier der gesamte Code,ich hoffs ich habs einigermassen gerafft.

// Parallelogramm.
interface Parallelogram {
double side1 (); // Seiten.
double side2 ();
double angle (); // Ein Winkel (Bogenmaß).
double diag1 (); // Diagonalen.
double diag2 ();
double area (); // Fläche.
double circumference (); // Umfang.
}
// Rechteck.
interface Rectangle extends Parallelogram {
double diag (); // Diagonale (selber Wert wie diag1() und diag2()).
}
// Rhombus/Raute.
interface Rhombus extends Parallelogram {
double side (); // Seite (selber Wert wie side1() und side2()).
}
// Quadrat.
interface Square extends Rectangle, Rhombus {
}

abstract class AbstractParallelogram implements Parallelogram{
	
	protected double side2,side1;
	
	public AbstractParallelogram(double side1,double side2){
		this.side1=side1;
		this.side2=side2;
	}	
	
	public double diag1(){
		return Math.sqrt(side1*side1+side2*side2+2*side1*side2*Math.cos(Math.PI/2));
	}
	
	public double diag2(){
		return Math.sqrt(side1*side1+side2*side2-2*side1*side2*Math.cos(Math.PI/2));
	}
	
	public double area() {return side1*side2*Math.sin(Math.PI/2);}
	
	public double circumference() {return 2*(side1+side2);}
}

abstract class AbstractRectangle extends AbstractParallelogram implements Rectangle{
	
	public AbstractRectangle(double side1, double side2) {
		super(side1, side2);
	}
	
	public  double angle(){return Math.PI/2;}
	
	public  double diag(){return Math.sqrt(side1*side1+side2*side2);}
	
	public  double diag1(){return diag();}
	
	public  double diag2(){return diag();}
	
	public  double area(){return side1*side2;}
}

abstract class AbstractRhombus extends AbstractParallelogram implements Rhombus{
	public AbstractRhombus(double side1, double side2) {
		super(side1, side2);
	}
	
	public double side(){return side1;}
	
	public double side1(){return side();}
	
	public double side2(){return side1();}
	
	public double diag1(){return side2()*Math.sqrt(2*1+Math.cos(Math.PI/2));}
	
	public double diag2(){return side2()*Math.sqrt(2*1-Math.cos(Math.PI/2));}
}

abstract class AbstractSquare extends AbstractRectangle implements Square{
	public AbstractSquare(double side1, double side2) {
		super(side1, side2);
	}
	
	public double side1(){return side1;}
	
	public double side2(){return side1();}
	
	public double diag(){return side()*Math.sqrt(2);}
	
	public double diag1(){return diag();}
	
	public double diag2(){return diag();}
}

class ParallelogramImpl extends AbstractParallelogram{

	public ParallelogramImpl(double side1, double side2,double winkel) {
		super(side1, side2);
	}

	public double angle() {return 0;}

	public double side1() {return 0;}

	public double side2() {return 0;}
	
}

class RhombusImpl extends AbstractRhombus{

	public RhombusImpl(double side1, double side2) {
		super(side1, side2);
	}

	public double side() {return 0;}

	public double angle() {return 0;}
	
}


class RectangleImpl extends AbstractRectangle {

	public RectangleImpl(double side1, double side2) {
		super(side1, side2);
	}

	public double side1() {return 0;}

	public double side2() {return 0;}
	
}


class SquareImpl extends AbstractSquare{

	public SquareImpl(double side1, double side2) {
		super(side1, side2);
	}

	public double side() {return 0;}
	
}

[/code]

 

[hiti]

Hallo,
vielleicht will man eine zuvor protected- Deklarierte Variable in einer der SubKlassen vor fremden Zugriff schützen, und macht sie dann private ?

Gruss, hiti

 

[bygones]

versteh leider kein wort was du willst ;-)

Hallo,
vielleicht will man eine zuvor protected- Deklarierte Variable in einer der SubKlassen vor fremden Zugriff schützen, und macht sie dann private ?

wenn du in deiner Unterklasse eine protected variable der Oberklasse private "ueberschreibst" wird diese ignoriert...

public class K extends V {
    private String s;

    public static void main(String[] args) {
        new K().foo(); // ist HUHU
        new V() {}.foo(); // ist HUHU
    }
}

abstract class V {
    protected String s;

    V() {
        s = "HUHU";
    }

    public void foo() {
        System.out.println(s);
    }
}

 

[hiti]

ja, das stimmt. Für die direkt beteiligten Objekte ist das sinnlos.
Aber für z.B. andere Objekte aus dem Packet änder sich ja der Zugriff auf die Variable.

V.s wäre aus dem Pakage noch sichtbar, da protected.
K.s nicht mehr.

Gruss, hiti