# Klasse1 und Klasse2 soll auf Wert zugreifen können, Klasse 3 nicht



## ubik (20. Apr 2016)

Hallo,

ich stehe vor folgendem Problem.

Ich habe drei Klassen:

class Klasse1 {
}

class Klasse2 {
  String meineVariable;
}

class Klasse3 {
}

So. Jetzt soll Klasse1, Klasse2 und Klasse3 die Variable meineVariable lesen können. Aber nur die Klasse2 und Klasse3 soll auf meineVariable schreiben können.


----------



## Saheeda (20. Apr 2016)

Man kann mit unterschiedlichen Sichtbarkeiten für Getter und Setter arbeiten, indem beispielsweise der Getter auf package-protected gesetzt wird, erhalten nur Klassen im selben Package Schreibzugriff.

http://openbook.rheinwerk-verlag.de...05_002.htm#mjf5b3fff9748ae6323d1923016a906a8f


----------



## Schesam (20. Apr 2016)

Theoretisch könnte man getter und setter für die Variable hinzufügen und in diesen mit Reflection.getCallerClass(); die aufrufende Klasse herausfinden und dann schauen, ob es der Klasse gestattet ist, die Methode aufzurufen, wenn nein, eine Exception werfen.

Aber ich denke wenn du mit protected bzw package-private hantierst, wird das einfacher für dich zu verstehen sein.


----------



## Joose (20. Apr 2016)

Mittels "package-private" wäre es möglich, dazu müssen aber die Klasse 2&3 im gleichen Package sein, Klasse 1 aber in einen anderen.
Mittels "protected" wäre es möglich wenn die eine Klasse die andere erweiteren würde.

Vielleicht erklärst du uns kurz was genau dein Ziel ist, vielleicht können wir dir dann noch weitere Möglichkeiten nennen.
Ein Beispiel wären 2 verschiedene Interfaces.


----------



## Jardcore (20. Apr 2016)

Um die vorangegangenen Posts mit ein wenig Code zu erweitern.

```
public class Klasse2 {
    private String meineVariable;

    public String getMeineVariable() {
        return meineVariable;
    }

    void setMeineVariable(String wert) {
        meineVariable = wert;
    }
}
```

Durch das weglassen des Sichtbarkeitsmodifizierers ist eine Methode "package private". Die Klasse 2 & 3 würden dann im gleichen Package liegen.

Aber wie Joose schon erwähnt hat, ist es vielleicht nützlicher für dich dein eigentliche Problem zu schildern, damit dir eine optimalere Lösung aufgezeigt werden kann.


----------



## ubik (20. Apr 2016)

Hallo, ich habe jetzt:


```
import firma.chefetage.Chef;

class Mitarbeiter extends Chef {
   int budget;
}
```


```
package firma.chefetage;

public class Chef {
   String naechsterTermin = "test";
  
   public String getTermin() {
     return this.naechsterTermin;
   }
  
   void setTermin(String t) {
     this.naechsterTermin = t;
   }  
}
```


```
package firma.chefetage;

public class ChefSekretaerin extends Chef {
}
```

Wenn ich aber in der main()-Methode chef.setTermin() aufrufe, sagt mir Eclipse, dass die Methode nicht aufgerufen werden kann, warum?


```
import firma.chefetage.*;

public class Main {
   public static void main(String[] args) {
     Chef chef = new Chef();
     Mitarbeiter mitarbeiter = new Mitarbeiter();
     ChefSekretaerin chefsekretaerin = new ChefSekretaerin();
    
     System.out.println(chef.getTermin());
     System.out.println(mitarbeiter.getTermin());
     System.out.println(chefsekretaerin.getTermin());
    
     chef.setTermin("Test");
    
   }
}
```


----------



## Jardcore (20. Apr 2016)

Ist deine Klasse mit der Main Methode im gleichen Package wie deine Chef Klasse?

Btw. du solltest wohl eher Interfaces benutzten.
Ein Mitarbeiter ist doch kein Spezialfall von Chef oder?

Vielleicht eher andersrum, der Chef ist ein Spezialfall von Mitarbeiter

Hier nochmal der Hinweis, beschreibe doch am besten die eigentliche Aufgabe.


----------



## ubik (20. Apr 2016)

Die Aufgabe lautet:


```
class Mitarbeiter {
    int budget;
}

class Chef {
    String naechsterTermin;
}

class ChefSekretaerin {
}
```

Welche Änderungen sind nötig, damit der nächste Termin eines Chefs von
allen Mitarbeitern gelesen, aber nur von Chefs und Chefsekretärinnen ge-
schrieben werden kann?

Interfaces haben wir noch gar nicht besprochen.

Kann doch nicht so schwer sein!  Muss man wahrscheinlich irgendwie mit Paketen lösen.


----------



## JStein52 (20. Apr 2016)

Ja, steht ja oben: Mitarbeiter in einem package, Chef und Chefsekretaerin in ein anderes.


----------



## ubik (20. Apr 2016)

Jupp, genauso geht's. Danke! Thema geschlossen.


----------



## udo-100 (20. Apr 2016)

```
/**
*
* @author udo-100
*/
class Mitarbeiter {

    int budget;

}

class Chef extends Mitarbeiter {

    String naechsterTermin;

    public String getNaechsterTermin() {
        return naechsterTermin;
    }

    protected void setNaechsterTermin(String naechsterTermin) {
        this.naechsterTermin = naechsterTermin;
    }

    class ChefSekretaerin extends Chef {

    }

}
```

Was haltet Ihr von dieser Lösung?


----------



## Harry Kane (20. Apr 2016)

udo-100 hat gesagt.:


> *class* ChefSekretaerin *extends* Chef


Was? Dann kann die Chefsekretärin demnächst auch Mitarbeiter feuern und ein paar noch zu spezifizierende Dinge, die ein Chef nicht kann?


----------



## mrBrown (20. Apr 2016)

udo-100 hat gesagt.:


> ```
> /**
> *
> * @author udo-100
> ...



Das ist ein super Beispiel für Vererbung, die zwar Code spart, aber keine ist-Beziehung ist, und hier auch fehl am Platz ist


----------



## InfectedBytes (21. Apr 2016)

```
class Mitabreiter {

}

class Chef extends Mitarbeiter {
  private String termin;
  public String getNaechsterTermin() { return termin; }
  private void setNaechsterTermin(String termin) { this.termin = termin; }
  class Sekretärin extends Mitarbeiter {

  }
}
```

Die Sekretärin wurde nun als innere Klasse von Chef deklariert.
Dadurch kann man nur eine Sekretärin haben, wenn man auch einen Chef hat. Zudem hat jede Sekretärin implizit einen Chef und sie kann auch die privaten Dinge von Chef benutzen


----------



## JStein52 (21. Apr 2016)

Harry Kane hat gesagt.:


> Was? Dann kann die Chefsekretärin demnächst auch Mitarbeiter feuern und ein paar noch zu spezifizierende Dinge, die ein Chef nicht kann


Ist das nicht die Realität ?  Also doch eine Ist-Beziehung


----------



## InfectedBytes (21. Apr 2016)

Noch eine Möglichkeit die etwas besser ist, da hier die Sekretärin nicht auf private Dinge zugreifen kann:

```
class Mitarbeiter { }
```


```
package chefetage;
class Chef extends Mitarbeiter {
  private String termin;
  public String getTermin() { return termin; }
  void setTermin(String termin) { this.termin = termin; }
}

class Sekretaerin extends Mitarbeiter {

}
```

Chef und Sekretaerin sind nun in einem separaten package und die setTermin methode ist nur in diesem package sichtbar. Der allgmeine Mitarbeiter liegt in einem anderen package und kann daher nur die getTermin methode vom Chef aufrufen


----------



## udo-100 (21. Apr 2016)

Harry Kane hat gesagt.:


> Was? Dann kann die Chefsekretärin demnächst auch Mitarbeiter feuern und ein paar noch zu spezifizierende Dinge, die ein Chef nicht kann?


*Also wenn ich eine Frau wäre würde ich so argumentieren.*
"Eine Chefsekretärin verdient zwar weniger Geld, muss aber mehr wissen, soll alles können und die unangenehmen Arbeiten übernehmen." 
Deshalb erbt Sie vom Chef. 
Und wenn Sie sowieso was mit dem Chef hat, wird er keine Geheimnisse vor Ihr haben.


----------



## mrBrown (21. Apr 2016)

Wenn jeder Chef eine Sekretärin hat, und jede Sekretärin ein Chef ist, hat dann jede Sekretärin eine Sekretärin, welche eine Sekretärin hat, welche eine Sekretärin hat, usw...?


----------

